var G_Domain = "http://www.zhijizhibi.com";

function G(id){
    return document.getElementById(id);
}

function PG(id){
    return parent.document.getElementById(id);
}

/*
 * tag, ad js
 */
function switchTag(tag,tagp,content,contentp,num)
{
//	alert(tag);
//	alert(content);
	for(i=0; i<num; i++)
	{
		if (tagp+i==tag)
		{
			G(tag).className="active";
		}else{
			G(tagp+i).className="normal";
		}
		if (contentp+i==content)
		{
			G(content).style.display="block";
		}else{
			G(contentp+i).style.display="none";
		}
	}
}

// JavaScript Document
var bannerAD=new Array();
var bannerADlink=new Array();
var adNum=0;   

bannerAD[0]="http://static2.zhijizhibi.com/e0220/images/indexad1.jpg";
bannerADlink[0]="http://static2.zhijizhibi.com/e0220/images/indexad1.jpg";
bannerAD[1]="http://static2.zhijizhibi.com/e0220/images/indexad1.jpg";
bannerADlink[1]="http://static2.zhijizhibi.com/e0220/images/indexad1.jpg";
bannerAD[2]="http://static2.zhijizhibi.com/e0220/images/indexad2.jpg";
bannerADlink[2]="http://static2.zhijizhibi.com/e0220/images/indexad2.jpg";
bannerAD[3]="http://static2.zhijizhibi.com/e0220/images/indexad3.jpg";
bannerADlink[3]="http://static2.zhijizhibi.com/e0220/images/indexad3.jpg";
bannerAD[4]="http://static2.zhijizhibi.com/e0220/images/indexad4.jpg";
bannerADlink[4]="http://static2.zhijizhibi.com/e0220/images/indexad4.jpg";
bannerAD[5]="http://static2.zhijizhibi.com/e0220/images/indexad5.jpg";
bannerADlink[5]="http://static2.zhijizhibi.com/e0220/images/indexad5.jpg";
bannerAD[5]="http://static2.zhijizhibi.com/e0220/images/indexad6.jpg";
bannerADlink[5]="http://static2.zhijizhibi.com/e0220/images/indexad6.jpg";

var preloadedimages=new Array();
for (i=1;i<bannerAD.length;i++){
  preloadedimages[i]=new Image();
  preloadedimages[i].src=bannerAD[i];
}

function setTransition(){
   if (document.all){
      bannerADrotator.filters.revealTrans.Transition=Math.floor(Math.random()*23);
      bannerADrotator.filters.revealTrans.apply();
   }
}

function playTransition(){
   if (document.all)
      bannerADrotator.filters.revealTrans.play()
}

function nextAd(){
   if(adNum<bannerAD.length-1)adNum++ ;
      else adNum=0;
   setTransition();
   document.images.bannerADrotator.src=bannerAD[adNum];
   playTransition();
   theTimer=setTimeout("nextAd()", 3000);
}

/* 列表框JS */
/*
Copyright (c) 2005 Tim Taylor Consulting <http://tool-man.org/>

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
*/

var ToolMan = {
    events : function() {
        if (!ToolMan._eventsFactory) throw "ToolMan Events module isn't loaded";
        return ToolMan._eventsFactory
    },

    css : function() {
        if (!ToolMan._cssFactory) throw "ToolMan CSS module isn't loaded";
        return ToolMan._cssFactory
    },

    coordinates : function() {
        if (!ToolMan._coordinatesFactory) throw "ToolMan Coordinates module isn't loaded";
        return ToolMan._coordinatesFactory
    },

    drag : function() {
        if (!ToolMan._dragFactory) throw "ToolMan Drag module isn't loaded";
        return ToolMan._dragFactory
    },

    dragsort : function() {
        if (!ToolMan._dragsortFactory) throw "ToolMan DragSort module isn't loaded";
        return ToolMan._dragsortFactory
    },

    helpers : function() {
        return ToolMan._helpers
    },
/*
    cookies : function() {
        if (!ToolMan._cookieOven) throw "ToolMan Cookie module isn't loaded";
        return ToolMan._cookieOven
    },
*/
    junkdrawer : function() {
        return ToolMan._junkdrawer
    }

}

ToolMan._helpers = {
    map : function(array, func) {
        for (var i = 0, n = array.length; i < n; i++) func(array[i])
    },

    getItem : function(item, nodeName, direct) {
        if (item == null) return
        
        if (direct == 1)
            var i = item.nextSibling
        else
            var i = item.previousSibling
            
        while (i != null) {
            if (i.nodeName == nodeName) return i
            
            if (direct == 1)
                i = i.nextSibling
            else
                i = i.previousSibling
        }
        return null
    },

    nextItem : function(item, nodeName) {
        return this.getItem(item, nodeName, 1)
    },
    
    previousItem : function(item, nodeName) {
        return this.getItem(item, nodeName, 0)
    },
/*
    nextItem : function(item, nodeName) {
        if (item == null) return
        var next = item.nextSibling
        while (next != null) {
            if (next.nodeName == nodeName) return next
            next = next.nextSibling
        }
        return null
    },

    previousItem : function(item, nodeName) {
        var previous = item.previousSibling
        while (previous != null) {
            if (previous.nodeName == nodeName) return previous
            previous = previous.previousSibling
        }
        return null
    },
*/
    moveBefore : function(item1, item2) {
        var parent = item1.parentNode
        parent.removeChild(item1)
        parent.insertBefore(item1, item2)
    },

    moveAfter : function(item1, item2) {
        this.moveBefore(item1, item2 ? item2.nextSibling : null)
/*
        var parent = item1.parentNode
        parent.removeChild(item1)
        parent.insertBefore(item1, item2 ? item2.nextSibling : null)
*/
    }
}

/** 
 * scripts without a proper home
 *
 * stuff here is subject to change unapologetically and without warning
 */
ToolMan._junkdrawer = {
    serializeList : function(list,join) {
        var items = list.getElementsByTagName("li")
        if (items.length<=0)
            items = list.getElementsByTagName("div")
        var array = new Array()
        for (var i = 0, n = items.length; i < n; i++) {
            var item = items[i]

            array.push(ToolMan.junkdrawer()._identifier(item))
        }
        if (join)
            return array.join('|')
        else
            return array
    },

    inspectListOrder : function(id,join) {
        return ToolMan.junkdrawer().serializeList(G(id),join)
    },
    
/*
    restoreListOrder : function(listID) {
        var list = G(listID)
        if (list == null) return

        var cookie = ToolMan.cookies().get("list-" + listID)
        if (!cookie) return;

        var IDs = cookie.split('|')
        var items = ToolMan.junkdrawer()._itemsByID(list)

        for (var i = 0, n = IDs.length; i < n; i++) {
            var itemID = IDs[i]
            if (itemID in items) {
                var item = items[itemID]
                list.removeChild(item)
                list.insertBefore(item, null)
            }
        }
    },
*/
    _identifier : function(item) {
        var trim = ToolMan.junkdrawer().trim
        var identifier

        identifier = trim(item.getAttribute("id"))
        if (identifier != null && identifier.length > 0) return identifier;
        
        identifier = trim(item.getAttribute("itemID"))
        if (identifier != null && identifier.length > 0) return identifier;
        
        // FIXME: strip out special chars or make this an MD5 hash or something
        return trim(item.innerHTML)
    },
/*
    _itemsByID : function(list) {
        var array = new Array()
        var items = list.getElementsByTagName('li')
        for (var i = 0, n = items.length; i < n; i++) {
            var item = items[i]
            array[ToolMan.junkdrawer()._identifier(item)] = item
        }
        return array
    },
*/
    trim : function(text) {
        if (text == null) return null
        return text.replace(/^(\s+)?(.*\S)(\s+)?$/, '$2')
    }
}
/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */

// TODO: write unit tests
ToolMan._cssFactory = {
    readStyle : function(element, property) {
        if (element.style[property]) {
            return element.style[property]
        } else if (element.currentStyle) {
            return element.currentStyle[property]
        } else if (document.defaultView && document.defaultView.getComputedStyle) {
            var style = document.defaultView.getComputedStyle(element, null)
            return style.getPropertyValue(property)
        } else {
            return null
        }
    }
}
/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */

ToolMan._dragFactory = {
    createSimpleGroup : function(element, handle) {
        handle = handle ? handle : element
        var group = this.createGroup(element)
        group.setHandle(handle)
        group.transparentDrag()
        group.onTopWhileDragging()
        return group
    },

    createGroup : function(element) {
        var group = new _ToolManDragGroup(this, element)

        var position = ToolMan.css().readStyle(element, 'position')
        if (position == 'static') {
            element.style["position"] = 'relative'
        } else if (position == 'absolute') {
            /* for Safari 1.2 */
            ToolMan.coordinates().topLeftOffset(element).reposition(element)
        }

        // TODO: only if ToolMan.isDebugging()
        /*
        group.register('draginit', this._showDragEventStatus)
        group.register('dragmove', this._showDragEventStatus)
        group.register('dragend', this._showDragEventStatus)
        */

        return group
    },

    _showDragEventStatus : function(dragEvent) {
        window.status = dragEvent.toString()
    },

    constraints : function() {
        return this._constraintFactory
    },

    _createEvent : function(type, event, group) {
        return new _ToolManDragEvent(type, event, group)
    }
}

function _ToolManDragGroup(factory, element) {
    this.factory = factory
    this.element = element
    this._handle = null
    this._thresholdDistance = 0
    this._transforms = new Array()
    // TODO: refactor into a helper object, move into events.js
    this._listeners = new Array()
    this._listeners['draginit'] = new Array()
    this._listeners['dragstart'] = new Array()
    this._listeners['dragmove'] = new Array()
    this._listeners['dragend'] = new Array()
}

_ToolManDragGroup.prototype = {
    /*
     * TODO:
     *   - unregister(type, func)
     *   - move custom event listener stuff into Event library
     *   - keyboard nudging of "selected" group
     */

    setHandle : function(handle) {
        var events = ToolMan.events()

        handle.toolManDragGroup = this
        events.register(handle, 'mousedown', this._dragInit)
        handle.onmousedown = function() { return false }

        if (this.element != handle)
            events.unregister(this.element, 'mousedown', this._dragInit)
    },

    register : function(type, func) {
        this._listeners[type].push(func)
    },

    addTransform : function(transformFunc) {
        this._transforms.push(transformFunc)
    },

    verticalOnly : function() {
        this.addTransform(this.factory.constraints().vertical())
    },

    horizontalOnly : function() {
        this.addTransform(this.factory.constraints().horizontal())
    },

    setThreshold : function(thresholdDistance) {
        this._thresholdDistance = thresholdDistance
    },

    transparentDrag : function(opacity) {
        var opacity = typeof(opacity) != "undefined" ? opacity : 0.75;
        var originalOpacity = ToolMan.css().readStyle(this.element, "opacity")

        this.register('dragstart', function(dragEvent) {
            var element = dragEvent.group.element
            element.style.opacity = opacity
            element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')'
        })
        this.register('dragend', function(dragEvent) {
            var element = dragEvent.group.element
            element.style.opacity = originalOpacity
            element.style.filter = 'alpha(opacity=100)'
        })
    },

    onTopWhileDragging : function(zIndex) {
        var zIndex = typeof(zIndex) != "undefined" ? zIndex : 100000;
        var originalZIndex = ToolMan.css().readStyle(this.element, "z-index")
        originalZIndex = typeof(originalZIndex) != "undefined" ? originalZIndex : 100000;

        this.register('dragstart', function(dragEvent) {
            dragEvent.group.element.style.zIndex = zIndex
        })
        this.register('dragend', function(dragEvent) {
            dragEvent.group.element.style.zIndex = originalZIndex
        })
    },

    _dragInit : function(event) {
        event = ToolMan.events().fix(event)
        var group = document.toolManDragGroup = this.toolManDragGroup
        if (!group) return
        var dragEvent = group.factory._createEvent('draginit', event, group)

        group._isThresholdExceeded = false
        group._initialMouseOffset = dragEvent.mouseOffset
        group._grabOffset = dragEvent.mouseOffset.minus(dragEvent.topLeftOffset)
        ToolMan.events().register(document, 'mousemove', group._drag)
        document.onmousemove = function() { return false }
        ToolMan.events().register(document, 'mouseup', group._dragEnd)

        group._notifyListeners(dragEvent)
    },

    _drag : function(event) {
        event = ToolMan.events().fix(event)
        var coordinates = ToolMan.coordinates()
        var group = this.toolManDragGroup
        if (!group) return
        var dragEvent = group.factory._createEvent('dragmove', event, group)

        var newTopLeftOffset = dragEvent.mouseOffset.minus(group._grabOffset)

        // TODO: replace with DragThreshold object
        if (!group._isThresholdExceeded) {
            var distance = 
                    dragEvent.mouseOffset.distance(group._initialMouseOffset)
            if (distance < group._thresholdDistance) return
            group._isThresholdExceeded = true
            group._notifyListeners(
                    group.factory._createEvent('dragstart', event, group))
        }

        for (i in group._transforms) {
            var transform = group._transforms[i]
            newTopLeftOffset = transform(newTopLeftOffset, dragEvent)
        }

        var dragDelta = newTopLeftOffset.minus(dragEvent.topLeftOffset)
        var newTopLeftPosition = dragEvent.topLeftPosition.plus(dragDelta)
        newTopLeftPosition.reposition(group.element)
        dragEvent.transformedMouseOffset = newTopLeftOffset.plus(group._grabOffset)

        group._notifyListeners(dragEvent)

        var errorDelta = newTopLeftOffset.minus(coordinates.topLeftOffset(group.element))
        if (errorDelta.x != 0 || errorDelta.y != 0) {
            coordinates.topLeftPosition(group.element).plus(errorDelta).reposition(group.element)
        }
    },

    _dragEnd : function(event) {
        event = ToolMan.events().fix(event)
        var group = this.toolManDragGroup
        if (!group) return
        var dragEvent = group.factory._createEvent('dragend', event, group)

        group._notifyListeners(dragEvent)

        this.toolManDragGroup = null
        ToolMan.events().unregister(document, 'mousemove', group._drag)
        document.onmousemove = null
        ToolMan.events().unregister(document, 'mouseup', group._dragEnd)
        
        if (typeof(dragEnd_Notify)=="function")
            dragEnd_Notify();
    },

    _notifyListeners : function(dragEvent) {
        var listeners = this._listeners[dragEvent.type]
        for (i in listeners) {
            listeners[i](dragEvent)
        }
    }
}

function _ToolManDragEvent(type, event, group) {
    this.type = type
    this.group = group
    this.mousePosition = ToolMan.coordinates().mousePosition(event)
    this.mouseOffset = ToolMan.coordinates().mouseOffset(event)
    this.transformedMouseOffset = this.mouseOffset
    this.topLeftPosition = ToolMan.coordinates().topLeftPosition(group.element)
    this.topLeftOffset = ToolMan.coordinates().topLeftOffset(group.element)
}

_ToolManDragEvent.prototype = {
    toString : function() {
        return "mouse: " + this.mousePosition + this.mouseOffset + "    " +
                "xmouse: " + this.transformedMouseOffset + "    " +
                "left,top: " + this.topLeftPosition + this.topLeftOffset
    }
}

ToolMan._dragFactory._constraintFactory = {
    vertical : function() {
        return function(coordinate, dragEvent) {
            var x = dragEvent.topLeftOffset.x
            return coordinate.x != x
                    ? coordinate.factory.create(x, coordinate.y) 
                    : coordinate
        }
    },

    horizontal : function() {
        return function(coordinate, dragEvent) {
            var y = dragEvent.topLeftOffset.y
            return coordinate.y != y
                    ? coordinate.factory.create(coordinate.x, y) 
                    : coordinate
        }
    }
}
/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */

ToolMan._dragsortFactory = {
    makeSortable : function(item) {
        var group = ToolMan.drag().createSimpleGroup(item)

        group.register('dragstart', this._onDragStart)
        group.register('dragmove', this._onDragMove)
        group.register('dragend', this._onDragEnd)

        return group
    },

    /** 
     * Iterates over a list's items, making them sortable, applying
     * optional functions to each item.
     *
     * example: makeListSortable(myList, myFunc1, myFunc2, ... , myFuncN)
     */
    makeListSortable : function(list) {
        var helpers = ToolMan.helpers()
        var coordinates = ToolMan.coordinates()
        var items = list.getElementsByTagName("li")
        if (items.length<=0)
            items = list.getElementsByTagName("div")

        helpers.map(items, function(item) {
            var dragGroup = dragsort.makeSortable(item)
            dragGroup.setThreshold(4)
            var min, max
            dragGroup.addTransform(function(coordinate, dragEvent) {
                return coordinate.constrainTo(min, max)
            })
            dragGroup.register('dragstart', function() {
                var items = list.getElementsByTagName("li")
                if (items.length<=0)
                    items = list.getElementsByTagName("div")
                min = max = coordinates.topLeftOffset(items[0])
                for (var i = 1, n = items.length; i < n; i++) {
                    var offset = coordinates.topLeftOffset(items[i])
                    min = min.min(offset)
                    max = max.max(offset)
                }
            })
        })
        for (var i = 1, n = arguments.length; i < n; i++)
            helpers.map(items, arguments[i])
    },

    _onDragStart : function(dragEvent) {
    },

    _onDragMove : function(dragEvent) {
        var helpers = ToolMan.helpers()
        var coordinates = ToolMan.coordinates()

        var item = dragEvent.group.element
        var xmouse = dragEvent.transformedMouseOffset
        var moveTo = null

        var previous = helpers.previousItem(item, item.nodeName)
        while (previous != null) {
            var bottomRight = coordinates.bottomRightOffset(previous)
            if (xmouse.y <= bottomRight.y && xmouse.x <= bottomRight.x) {
                moveTo = previous
            }
            previous = helpers.previousItem(previous, item.nodeName)
        }
        if (moveTo != null) {
            helpers.moveBefore(item, moveTo)
            return
        }

        var next = helpers.nextItem(item, item.nodeName)
        while (next != null) {
            var topLeft = coordinates.topLeftOffset(next)
            if (topLeft.y <= xmouse.y && topLeft.x <= xmouse.x) {
                moveTo = next
            }
            next = helpers.nextItem(next, item.nodeName)
        }
        if (moveTo != null) {
            helpers.moveBefore(item, helpers.nextItem(moveTo, item.nodeName))
            return
        }
    },

    _onDragEnd : function(dragEvent) {
        ToolMan.coordinates().create(0, 0).reposition(dragEvent.group.element)
    }
}
/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */

ToolMan._eventsFactory = {
    fix : function(event) {
        if (!event) event = window.event

        if (event.target) {
            if (event.target.nodeType == 3) event.target = event.target.parentNode
        } else if (event.srcElement) {
            event.target = event.srcElement
        }

        return event
    },

    register : function(element, type, func) {
        if (element.addEventListener) {
            element.addEventListener(type, func, false)
        } else if (element.attachEvent) {
            if (!element._listeners) element._listeners = new Array()
            if (!element._listeners[type]) element._listeners[type] = new Array()
            var workaroundFunc = function() {
                func.apply(element, new Array())
            }
            element._listeners[type][func] = workaroundFunc
            element.attachEvent('on' + type, workaroundFunc)
        }
    },

    unregister : function(element, type, func) {
        if (element.removeEventListener) {
            element.removeEventListener(type, func, false)
        } else if (element.detachEvent) {
            if (element._listeners 
                    && element._listeners[type] 
                    && element._listeners[type][func]) {

                element.detachEvent('on' + type, 
                        element._listeners[type][func])
            }
        }
    }
}
/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */

/* FIXME: assumes position styles are specified in 'px' */

ToolMan._coordinatesFactory = {

    create : function(x, y) {
        // FIXME: Safari won't parse 'throw' and aborts trying to do anything with this file
        //if (isNaN(x) || isNaN(y)) throw "invalid x,y: " + x + "," + y
        return new _ToolManCoordinate(this, x, y)
    },

    origin : function() {
        return this.create(0, 0)
    },

    /*
     * FIXME: Safari 1.2, returns (0,0) on absolutely positioned elements
     */
    topLeftPosition : function(element) {
        var left = parseInt(ToolMan.css().readStyle(element, "left"))
        var left = isNaN(left) ? 0 : left
        var top = parseInt(ToolMan.css().readStyle(element, "top"))
        var top = isNaN(top) ? 0 : top

        return this.create(left, top)
    },

    bottomRightPosition : function(element) {
        return this.topLeftPosition(element).plus(this._size(element))
    },

    topLeftOffset : function(element) {
        var offset = this._offset(element) 

        var parent = element.offsetParent
        while (parent) {
            offset = offset.plus(this._offset(parent))
            parent = parent.offsetParent
        }
        return offset
    },

    bottomRightOffset : function(element) {
        return this.topLeftOffset(element).plus(
                this.create(element.offsetWidth, element.offsetHeight))
    },

    scrollOffset : function() {
        if (window.pageXOffset) {
            return this.create(window.pageXOffset, window.pageYOffset)
        } else if (document.documentElement) {
            return this.create(
                    document.body.scrollLeft + document.documentElement.scrollLeft, 
                    document.body.scrollTop + document.documentElement.scrollTop)
        } else if (document.body.scrollLeft >= 0) {
            return this.create(document.body.scrollLeft, document.body.scrollTop)
        } else {
            return this.create(0, 0)
        }
    },

    clientSize : function() {
        if (window.innerHeight >= 0) {
            return this.create(window.innerWidth, window.innerHeight)
        } else if (document.documentElement) {
            return this.create(document.documentElement.clientWidth,
                    document.documentElement.clientHeight)
        } else if (document.body.clientHeight >= 0) {
            return this.create(document.body.clientWidth,
                    document.body.clientHeight)
        } else {
            return this.create(0, 0)
        }
    },

    /**
     * mouse coordinate relative to the window (technically the
     * browser client area) i.e. the part showing your page
     *
     * NOTE: in Safari the coordinate is relative to the document
     */
    mousePosition : function(event) {
        event = ToolMan.events().fix(event)
        return this.create(event.clientX, event.clientY)
    },

    /**
     * mouse coordinate relative to the document
     */
    mouseOffset : function(event) {
        event = ToolMan.events().fix(event)
        if (event.pageX >= 0 || event.pageX < 0) {
            return this.create(event.pageX, event.pageY)
        } else if (event.clientX >= 0 || event.clientX < 0) {
            return this.mousePosition(event).plus(this.scrollOffset())
        }
    },

    _size : function(element) {
    /* TODO: move to a Dimension class */
        return this.create(element.offsetWidth, element.offsetHeight)
    },

    _offset : function(element) {
        return this.create(element.offsetLeft, element.offsetTop)
    }
}

function _ToolManCoordinate(factory, x, y) {
    this.factory = factory
    this.x = isNaN(x) ? 0 : x
    this.y = isNaN(y) ? 0 : y
}

_ToolManCoordinate.prototype = {
    toString : function() {
        return "(" + this.x + "," + this.y + ")"
    },

    plus : function(that) {
        return this.factory.create(this.x + that.x, this.y + that.y)
    },

    minus : function(that) {
        return this.factory.create(this.x - that.x, this.y - that.y)
    },

    min : function(that) {
        return this.factory.create(
                Math.min(this.x , that.x), Math.min(this.y , that.y))
    },

    max : function(that) {
        return this.factory.create(
                Math.max(this.x , that.x), Math.max(this.y , that.y))
    },

    constrainTo : function (one, two) {
        var min = one.min(two)
        var max = one.max(two)

        return this.max(min).min(max)
    },

    distance : function (that) {
        return Math.sqrt(Math.pow(this.x - that.x, 2) + Math.pow(this.y - that.y, 2))
    },

    reposition : function(element) {
        element.style["top"] = this.y + "px"
        element.style["left"] = this.x + "px"
    }
}

/**
 *  myself toolmandrag scripts
 */

function verticalOnly(item) {
    item.toolManDragGroup.verticalOnly()
}

function horizontalOnly(item) {
    item.toolManDragGroup.horizontalOnly()
}

function initDragList(listId) {
    dragsort = ToolMan.dragsort()
    dragsort.makeListSortable(G(listId), verticalOnly)
}

var dragsort;


/**
 *  myself scripts
 */

function Array_IndexOf(arr, elt /*, from*/)
{
    var len = arr.length;
     
    var from = Number(arguments[2]) || 0;
    from = (from < 0) ? Math.ceil(from) : Math.floor(from);
    if (from < 0)
        from += len;
     
    for (; from < len; from++)
    {
        if (from in arr && arr[from] === elt)
            return from;
    }
    return -1;
}

function boolean2int(val)
{
    if (val == true) return 1;
    else return 0;
}

function funThemeSel(s) 
{ 
    if (s.length==1) 
    { 
        var ajax = new sack(); 
        ajax.requestFile = "/ajax.php?op=5"; 
        ajax.method = "get"; 
        ajax.element = "themeidtd"; 
        ajax.runAJAX(); 
    }
}

function funDoSearch(sort)
{
    G('sortby').value = sort;
    var aform = G('formsearch');
    aform.method="post";
    aform.submit();
}

function funGoto(aform)
{
    aform.action = G_Domain+"/goto/query";
    aform.method="post";
    aform.submit();
    aform.action = G_Domain+"/search/query";
}

function funGotoHelp(aform)
{
    aform.action = G_Domain+"/goto/query";
    aform.method="post";
    aform.submit();
    aform.action = G_Domain+"/search/query";
}

function funOpenComment(questionnaireid)
{ 
    aform = G('commentform');
    aform.action = G_Domain+"/questionnaire/"+questionnaireid+"/preview?scroll=1";
    aform.target = "_blank";
    aform.method="post";
    aform.submit();
}

function funSysDemo()
{ 
    G('loginname').value = "sysdemo";
    G('loginpassword').value = "sysdemo";
    G('loginedaction').value = "";

    aform = G('loginform');
    aform.method="post";
    aform.submit();
}

function cloneParentSelectRowsByFormName(myFormName)
{
    var parentCheckRows = "selrows";
    var parentCheckRowsCnt = "selrowscnt";

    aForm = G(myFormName);

    for(i=1; i<=PG(parentCheckRowsCnt).value; i++)
    {
        if (PG(parentCheckRows+'['+i+']').checked)
        {
            parentObj = PG(parentCheckRows+'['+i+']');

            var eCheckRow = document.createElement("input");
            eCheckRow.setAttribute("id", parentObj.id);
            eCheckRow.setAttribute("type", "hidden");
            eCheckRow.setAttribute("name", parentObj.name);
            eCheckRow.setAttribute("value", parentObj.value);
            aForm.appendChild(eCheckRow);
        }
    }
}

function cloneParentAdvertiseInput(myFormName)
{
/*    var myFormName = "myForm"; */
    var parentTypeHiddenId = "type";
    var parentKeywordHiddenId = "keyword";
    var parentThemeIdHiddenId = "themeIdAdvertise";

    var parentOpSelInputId = "opSel";
    var parentPosSelInputId = "posSel";
    var parentExchangeDaysSelInputId = "exchangeDaysSel";
    var parentSelQuestionnaireId = "selrows";
    var parentSelQuestionnaireIdCnt = "selrowscnt";
 
    aForm = G(myFormName);

    parentObj = PG(parentTypeHiddenId);

    var eTypeHidden = document.createElement("input");
    eTypeHidden.setAttribute("id", parentObj.id);
    eTypeHidden.setAttribute("type", "hidden");
    eTypeHidden.setAttribute("name", parentObj.name);
    eTypeHidden.setAttribute("value", parentObj.value);
    aForm.appendChild(eTypeHidden);

    parentObj = PG(parentKeywordHiddenId);
    if (parentObj)
    {
        var eKeywordHidden = document.createElement("input");
        eKeywordHidden.setAttribute("id", parentObj.id);
        eKeywordHidden.setAttribute("type", "hidden");
        eKeywordHidden.setAttribute("name", parentObj.name);
        eKeywordHidden.setAttribute("value", parentObj.value);
        aForm.appendChild(eKeywordHidden);
    }

    parentObj = PG(parentThemeIdHiddenId);
    if (parentObj)
    {
        var eThemeHidden = document.createElement("input");
        eThemeHidden.setAttribute("id", parentObj.id);
        eThemeHidden.setAttribute("type", "hidden");
        eThemeHidden.setAttribute("name", "themeId");
        eThemeHidden.setAttribute("value", parentObj.value);
        aForm.appendChild(eThemeHidden);
    }

    parentObj = PG(parentOpSelInputId);

    var eOpSel = document.createElement("input");
    eOpSel.setAttribute("id", parentObj.id);
    eOpSel.setAttribute("type", "hidden");
    eOpSel.setAttribute("name", parentObj.name);
    eOpSel.setAttribute("value", parentObj.value);
    aForm.appendChild(eOpSel);

    parentObj = PG(parentPosSelInputId);

    var ePosSel = document.createElement("input");
    ePosSel.setAttribute("id", parentObj.id);
    ePosSel.setAttribute("type", "hidden");
    ePosSel.setAttribute("name", parentObj.name);
    ePosSel.setAttribute("value", parentObj.value);
    aForm.appendChild(ePosSel);

    parentObj = PG(parentExchangeDaysSelInputId);

    var eExchangeDays = document.createElement("input");
    eExchangeDays.setAttribute("id", parentObj.id);
    eExchangeDays.setAttribute("type", "hidden");
    eExchangeDays.setAttribute("name", parentObj.name);
    eExchangeDays.setAttribute("value", parentObj.value);
    aForm.appendChild(eExchangeDays);

    for(i=1; i<=PG(parentSelQuestionnaireIdCnt).value; i++)
    {
        if (PG(parentSelQuestionnaireId+'['+i+']').checked)
        {
            parentObj = PG(parentSelQuestionnaireId+'['+i+']');
            var eCheckQuestionnaire = document.createElement("input");
            eCheckQuestionnaire.setAttribute("id", parentObj.id);
            eCheckQuestionnaire.setAttribute("type", "hidden");
            eCheckQuestionnaire.setAttribute("name", parentObj.name);
            eCheckQuestionnaire.setAttribute("value", parentObj.value);
            aForm.appendChild(eCheckQuestionnaire);
        }
    }

}

function cloneParentInput(myFormName)
{
//    var myFormName = "myForm";
    var parentTitleInputId = "title";
    var parentDescriptionInputId = "qdescription";
    var parentWelcomeWordsInputId = "welcomewords";
    var parentEndWordsInputId = "endwords";
    var parentSelectConditionSubject = "selectconditionsubject";
    var parentSelectConditionChoise = "selectconditionsubchoise";
    var parentSelectOriginSubject = "selectoriginsubject";
    var parentSelectDistSubject = "selectdistsubject";
    var parentAdditions = "additions";
 
    aForm = G(myFormName);

    parentObj = PG(parentTitleInputId);

    var eTitle = document.createElement("input");
    eTitle.setAttribute("id", parentObj.id);
    eTitle.setAttribute("type", "hidden");
    eTitle.setAttribute("name", parentObj.name);
    eTitle.setAttribute("value", parentObj.value);
    aForm.appendChild(eTitle);

    parentObj = PG(parentDescriptionInputId);

    var eDescription = document.createElement("input");
    eDescription.setAttribute("id", parentObj.id);
    eDescription.setAttribute("type", "hidden");
    eDescription.setAttribute("name", parentObj.name);
    eDescription.setAttribute("value", parentObj.value);
    aForm.appendChild(eDescription);

    parentObj = PG(parentWelcomeWordsInputId);

    var eWelcomeWords = document.createElement("input");
    eWelcomeWords.setAttribute("id", parentObj.id);
    eWelcomeWords.setAttribute("type", "hidden");
    eWelcomeWords.setAttribute("name", parentObj.name);
    eWelcomeWords.setAttribute("value", parentObj.value);
    aForm.appendChild(eWelcomeWords);

    parentObj = PG(parentEndWordsInputId);

    var eEndWords = document.createElement("input");
    eEndWords.setAttribute("id", parentObj.id);
    eEndWords.setAttribute("type", "hidden");
    eEndWords.setAttribute("name", parentObj.name);
    eEndWords.setAttribute("value", parentObj.value);
    aForm.appendChild(eEndWords);

    for(i=1; i<=parent.logicNumber; i++)
    {
        parentObj = PG(parentSelectConditionSubject+'['+i+']');
        var eSelectConditionSubject = document.createElement("input");
        eSelectConditionSubject.setAttribute("id", parentObj.id);
        eSelectConditionSubject.setAttribute("type", "hidden");
        eSelectConditionSubject.setAttribute("name", parentObj.name);
        eSelectConditionSubject.setAttribute("value", parentObj.value);
        aForm.appendChild(eSelectConditionSubject);
    }

    for(i=1; i<=parent.logicNumber; i++)
    {
        parentObj = PG(parentSelectConditionChoise+'['+i+']');
        var eSelectConditionChoise = document.createElement("input");
        eSelectConditionChoise.setAttribute("id", parentObj.id);
        eSelectConditionChoise.setAttribute("type", "hidden");
        eSelectConditionChoise.setAttribute("name", parentObj.name);
        eSelectConditionChoise.setAttribute("value", parentObj.value);
        aForm.appendChild(eSelectConditionChoise);
    }

    for(i=1; i<=parent.logicNumber; i++)
    {
        parentObj = PG(parentSelectOriginSubject+'['+i+']');
        var eSelectOriginSubject = document.createElement("input");
        eSelectOriginSubject.setAttribute("id", parentObj.id);
        eSelectOriginSubject.setAttribute("type", "hidden");
        eSelectOriginSubject.setAttribute("name", parentObj.name);
        eSelectOriginSubject.setAttribute("value", parentObj.value);
        aForm.appendChild(eSelectOriginSubject);
    }

    for(i=1; i<=parent.logicNumber; i++)
    {
        parentObj = PG(parentSelectDistSubject+'['+i+']');
        var eSelectDistSubject = document.createElement("input");
        eSelectDistSubject.setAttribute("id", parentObj.id);
        eSelectDistSubject.setAttribute("type", "hidden");
        eSelectDistSubject.setAttribute("name", parentObj.name);
        eSelectDistSubject.setAttribute("value", parentObj.value);
        aForm.appendChild(eSelectDistSubject);
    }

    for(i=parent.startPos; i<=parent.endPos; i++)
    {
        parentObj = PG(parentAdditions+'['+i+']');
        if (parentObj)
        {
            var eAdditionInput = document.createElement("input");
            eAdditionInput.setAttribute("id", parentObj.id);
            eAdditionInput.setAttribute("type", "hidden");
            eAdditionInput.setAttribute("name", parentObj.name);
            eAdditionInput.setAttribute("value", parentObj.value);
            aForm.appendChild(eAdditionInput);
        }
    }
}


function scrollToTarget(targetId)
{
    var target = G(targetId);
    if (target)
    {
        var offsetTop = 0;
        while (target) {
            if (target.tagName.toUpperCase() == "BODY") break;

            offsetTop += target.offsetTop;
            target = target.offsetParent;
        }

        this.window.scrollTo(0,document.body.offsetTop+offsetTop);  
    }
    else
    {
        this.window.scrollTo(0,0);  
    }
}

function appendScroll(url, scroll)
{
	if (url.indexOf('?') == -1)
		url = url+'?'+scroll;
	else
		url = url+'&'+scroll;
		
	return url;
}