class mx.core.ScrollView extends mx.core.View

{

        var __width, hScroller, vScroller, __maxHPosition, propsInited, scrollAreaChanged, specialHScrollCase, createObject, viewableColumns, __height, oldRndUp, viewableRows, __viewMetrics, owner, enabled, border_mc, __get__width, __get__height, invLayout, mask_mc, _parent, dispatchEvent;

        function ScrollView () {

                super();

        }

        function getHScrollPolicy(Void) {

                return(__hScrollPolicy);

        }

        function setHScrollPolicy(policy) {

                __hScrollPolicy = policy.toLowerCase();

                if (__width == undefined) {

                        return(undefined);

                }

                setScrollProperties(numberOfCols, columnWidth, rowC, rowH, heightPadding, widthPadding);

        }

        function get hScrollPolicy() {

                return(getHScrollPolicy());

        }

        function set hScrollPolicy(policy) {

                setHScrollPolicy(policy);

                //return(hScrollPolicy);

        }

        function getVScrollPolicy(Void) {

                return(__vScrollPolicy);

        }

        function setVScrollPolicy(policy) {

                __vScrollPolicy = policy.toLowerCase();

                if (__width == undefined) {

                        return(undefined);

                }

                setScrollProperties(numberOfCols, columnWidth, rowC, rowH, heightPadding, widthPadding);

        }

        function get vScrollPolicy() {

                return(getVScrollPolicy());

        }

        function set vScrollPolicy(policy) {

                setVScrollPolicy(policy);

                //return(vScrollPolicy);

        }

        function get hPosition() {

                return(getHPosition());

        }

        function set hPosition(pos) {

                setHPosition(pos);

                //return(hPosition);

        }

        function getHPosition(Void) {

                return(__hPosition);

        }

        function setHPosition(pos) {

                hScroller.__set__scrollPosition(pos);

                __hPosition = pos;

        }

        function get vPosition() {

                return(getVPosition());

        }

        function set vPosition(pos) {

                setVPosition(pos);

                //return(vPosition);

        }

        function getVPosition(Void) {

                return(__vPosition);

        }

        function setVPosition(pos) {

                vScroller.__set__scrollPosition(pos);

                __vPosition = pos;

        }

        function get maxVPosition() {

                var _local2 = vScroller.maxPos;

                return(((_local2 == undefined) ? 0 : (_local2)));

        }

        function get maxHPosition() {

                return(getMaxHPosition());

        }

        function set maxHPosition(pos) {

                setMaxHPosition(pos);

                //return(maxHPosition);

        }

        function getMaxHPosition(Void) {

                if (__maxHPosition != undefined) {

                        return(__maxHPosition);

                }

                var _local2 = hScroller.maxPos;

                return(((_local2 == undefined) ? 0 : (_local2)));

        }

        function setMaxHPosition(pos) {

                __maxHPosition = pos;

        }

        function setScrollProperties(colCount, colWidth, rwCount, rwHeight, hPadding, wPadding) {

                var _local3 = getViewMetrics();

                if (hPadding == undefined) {

                        hPadding = 0;

                }

                if (wPadding == undefined) {

                        wPadding = 0;

                }

                propsInited = true;

                delete scrollAreaChanged;

                heightPadding = hPadding;

                widthPadding = wPadding;

                if (colWidth == 0) {

                        colWidth = 1;

                }

                if (rwHeight == 0) {

                        rwHeight = 1;

                }

                var _local4 = Math.ceil((((__width - _local3.left) - _local3.right) - widthPadding) / colWidth);

                if ((__hScrollPolicy == "on") || ((_local4 < colCount) && (__hScrollPolicy == "auto"))) {

                        if ((hScroller == undefined) || (specialHScrollCase)) {

                                delete specialHScrollCase;

                                hScroller = mx.controls.scrollClasses.ScrollBar(createObject("HScrollBar", "hSB", 1001));

                                hScroller.__set__lineScrollSize(20);

                                hScroller.scrollHandler = scrollProxy;

                                hScroller.__set__scrollPosition(__hPosition);

                                scrollAreaChanged = true;

                        }

                        if ((((numberOfCols != colCount) || (columnWidth != colWidth)) || (viewableColumns != _local4)) || (scrollAreaChanged)) {

                                hScroller.setScrollProperties(_local4, 0, colCount - _local4);

                                viewableColumns = _local4;

                                numberOfCols = colCount;

                                columnWidth = colWidth;

                        }

                } else if (((__hScrollPolicy == "auto") || (__hScrollPolicy == "off")) && (hScroller != undefined)) {

                        hScroller.removeMovieClip();

                        delete hScroller;

                        scrollAreaChanged = true;

                }

                if (heightPadding == undefined) {

                        heightPadding = 0;

                }

                var _local5 = Math.ceil((((__height - _local3.top) - _local3.bottom) - heightPadding) / rwHeight);

                var _local8 = (((__height - _local3.top) - _local3.bottom) % rwHeight) != 0;

                if ((__vScrollPolicy == "on") || ((_local5 < (rwCount + _local8)) && (__vScrollPolicy == "auto"))) {

                        if (vScroller == undefined) {

                                vScroller = mx.controls.scrollClasses.ScrollBar(createObject("VScrollBar", "vSB", 1002));

                                vScroller.scrollHandler = scrollProxy;

                                vScroller.__set__scrollPosition(__vPosition);

                                scrollAreaChanged = true;

                                rowH = 0;

                        }

                        if ((((rowC != rwCount) || (rowH != rwHeight)) || ((viewableRows + _local8) != (_local5 + oldRndUp))) || (scrollAreaChanged)) {

                                vScroller.setScrollProperties(_local5, 0, (rwCount - _local5) + _local8);

                                viewableRows = _local5;

                                rowC = rwCount;

                                rowH = rwHeight;

                                oldRndUp = _local8;

                        }

                } else if (((__vScrollPolicy == "auto") || (__vScrollPolicy == "off")) && (vScroller != undefined)) {

                        vScroller.removeMovieClip();

                        delete vScroller;

                        scrollAreaChanged = true;

                }

                numberOfCols = colCount;

                columnWidth = colWidth;

                if (scrollAreaChanged) {

                        doLayout();

                        var _local2 = __viewMetrics;

                        var _local12 = ((owner != undefined) ? (owner) : this);

                        _local12.layoutContent(_local2.left, _local2.top, ((columnWidth * numberOfCols) - _local2.left) - _local2.right, rowC * rowH, (__width - _local2.left) - _local2.right, (__height - _local2.top) - _local2.bottom);

                }

                if (!enabled) {

                        setEnabled(false);

                }

        }

        function getViewMetrics(Void) {

                var _local2 = __viewMetrics;

                var _local3 = border_mc.__get__borderMetrics();

                _local2.left = _local3.left;

                _local2.right = _local3.right;

                if (vScroller != undefined) {

                        _local2.right = _local2.right + vScroller.minWidth;

                }

                _local2.top = _local3.top;

                if ((hScroller == undefined) && ((__hScrollPolicy == "on") || (__hScrollPolicy == true))) {

                        hScroller = mx.controls.scrollClasses.ScrollBar(createObject("FHScrollBar", "hSB", 1001));

                        specialHScrollCase = true;

                }

                _local2.bottom = _local3.bottom;

                if (hScroller != undefined) {

                        _local2.bottom = _local2.bottom + hScroller.minHeight;

                }

                return(_local2);

        }

        function doLayout(Void) {

                var _local10 = __get__width();

                var _local8 = __get__height();

                delete invLayout;

                var _local3 = (__viewMetrics = getViewMetrics());

                var _local2 = _local3.left;

                var _local9 = _local3.right;

                var _local5 = _local3.top;

                var _local11 = _local3.bottom;

                var _local7 = hScroller;

                var _local6 = vScroller;

                _local7.setSize((_local10 - _local2) - _local9, _local7.minHeight + 0);

                _local7.move(_local2, _local8 - _local11);

                _local6.setSize(_local6.minWidth + 0, (_local8 - _local5) - _local11);

                _local6.move(_local10 - _local9, _local5);

                var _local4 = mask_mc;

                _local4._width = (_local10 - _local2) - _local9;

                _local4._height = (_local8 - _local5) - _local11;

                _local4._x = _local2;

                _local4._y = _local5;

        }

        function createChild(id, name, props) {

                var _local2 = super.createChild(id, name, props);

                return(_local2);

        }

        function init(Void) {

                super.init();

                __viewMetrics = new Object();

                if (_global.__SVMouseWheelManager == undefined) {

                        var _local4 = (_global.__SVMouseWheelManager = new Object());

                        _local4.onMouseWheel = __onMouseWheel;

                        Mouse.addListener(_local4);

                }

        }

        function __onMouseWheel(delta, scrollTarget) {

                var _local4 = scrollTarget;

                var _local1;

                while (_local4 != undefined) {

                        if (_local4 instanceof mx.core.ScrollView) {

                                _local1 = _local4;

                        }

                        _local4 = _local4._parent;

                }

                if (_local1 != undefined) {

                        _local4 = ((delta <= 0) ? 1 : -1);

                        var _local2 = _local1.vScroller.lineScrollSize;

                        if (_local2 == undefined) {

                                _local2 = 0;

                        }

                        _local2 = Math.max(Math.abs(delta), _local2);

                        var _local3 = _local1.vPosition + (_local2 * _local4);

                        _local1.vPosition = Math.max(0, Math.min(_local3, _local1.maxVPosition));

                        _local1.dispatchEvent({type:"scroll", direction:"vertical", position:_local1.vPosition});

                }

        }

        function createChildren(Void) {

                super.createChildren();

                if (mask_mc == undefined) {

                        mask_mc = createObject("BoundingBox", "mask_mc", MASK_DEPTH);

                }

                mask_mc._visible = false;

        }

        function invalidate(Void) {

                super.invalidate();

        }

        function draw(Void) {

                this.size();

        }

        function size(Void) {

                super.size();

        }

        function scrollProxy(docObj) {

                _parent.onScroll(docObj);

        }

        function onScroll(docObj) {

                var _local3 = docObj.target;

                var _local2 = _local3.scrollPosition;

                if (_local3 == vScroller) {

                        var _local4 = "vertical";

                        var _local5 = "__vPosition";

                } else {

                        var _local4 = "horizontal";

                        var _local5 = "__hPosition";

                }

                this[_local5] = _local2;

                dispatchEvent({type:"scroll", direction:_local4, position:_local2});

        }

        function setEnabled(v) {

                vScroller.enabled = (hScroller.enabled = v);

        }

        function childLoaded(obj) {

                super.childLoaded(obj);

                obj.setMask(mask_mc);

        }

        static var symbolName = "ScrollView";

        static var symbolOwner = mx.core.ScrollView;

        static var version = "2.0.2.127";

        var className = "ScrollView";

        var __vScrollPolicy = "auto";

        var __hScrollPolicy = "off";

        var __vPosition = 0;

        var __hPosition = 0;

        var numberOfCols = 0;

        var rowC = 0;

        var columnWidth = 1;

        var rowH = 0;

        var heightPadding = 0;

        var widthPadding = 0;

        var MASK_DEPTH = 10000;

}

class mx.controls.scrollClasses.ScrollThumb extends mx.skins.CustomBorder

{

        var useHandCursor, ymin, ymax, datamin, datamax, scrollMove, lastY, _ymouse, _y, _parent, onMouseMove, grip_mc, setSkin, gripSkin, __get__width, __get__height;

        function ScrollThumb () {

                super();

        }

        function createChildren(Void) {

                super.createChildren();

                useHandCursor = false;

        }

        function setRange(_ymin, _ymax, _datamin, _datamax) {

                ymin = _ymin;

                ymax = _ymax;

                datamin = _datamin;

                datamax = _datamax;

        }

        function dragThumb(Void) {

                scrollMove = _ymouse - lastY;

                scrollMove = scrollMove + _y;

                if (scrollMove < ymin) {

                        scrollMove = ymin;

                } else if (scrollMove > ymax) {

                        scrollMove = ymax;

                }

                _parent.isScrolling = true;

                _y = scrollMove;

                var _local2 = Math.round(((datamax - datamin) * (_y - ymin)) / (ymax - ymin)) + datamin;

                _parent.scrollPosition = _local2;

                _parent.dispatchScrollEvent("ThumbTrack");

                updateAfterEvent();

        }

        function stopDragThumb(Void) {

                _parent.isScrolling = false;

                _parent.dispatchScrollEvent("ThumbPosition");

                _parent.dispatchScrollChangedEvent();

                delete onMouseMove;

        }

        function onPress(Void) {

                _parent.pressFocus();

                lastY = _ymouse;

                onMouseMove = dragThumb;

                super.onPress();

        }

        function onRelease(Void) {

                _parent.releaseFocus();

                stopDragThumb();

                super.onRelease();

        }

        function onReleaseOutside(Void) {

                _parent.releaseFocus();

                stopDragThumb();

                super.onReleaseOutside();

        }

        function draw() {

                super.draw();

                if (grip_mc == undefined) {

                        setSkin(3, gripSkin);

                }

        }

        function size() {

                super.size();

                grip_mc.move((__get__width() - grip_mc.width) / 2, (__get__height() - grip_mc.height) / 2);

        }

        static var symbolOwner = mx.skins.CustomBorder.symbolOwner;

        var className = "ScrollThumb";

        var btnOffset = 0;

        var horizontal = false;

        var idNames = new Array("l_mc", "m_mc", "r_mc", "grip_mc");

}

class mx.controls.scrollClasses.ScrollBar extends mx.core.UIComponent

{

        var isScrolling, scrollTrack_mc, scrollThumb_mc, __height, tabEnabled, focusEnabled, boundingBox_mc, setSkin, upArrow_mc, _minHeight, _minWidth, downArrow_mc, createObject, createClassObject, enabled, _height, dispatchEvent, minMode, maxMode, plusMode, minusMode, _parent, getStyle, scrolling, _ymouse;

        function ScrollBar () {

                super();

        }

        function get scrollPosition() {

                return(_scrollPosition);

        }

        function set scrollPosition(pos) {

                _scrollPosition = pos;

                if (isScrolling != true) {

                        pos = Math.min(pos, maxPos);

                        pos = Math.max(pos, minPos);

                        var _local3 = (((pos - minPos) * (scrollTrack_mc.height - scrollThumb_mc._height)) / (maxPos - minPos)) + scrollTrack_mc.top;

                        scrollThumb_mc.move(0, _local3);

                }

                //return(scrollPosition);

        }

        function get pageScrollSize() {

                return(largeScroll);

        }

        function set pageScrollSize(lScroll) {

                largeScroll = lScroll;

                //return(pageScrollSize);

        }

        function set lineScrollSize(sScroll) {

                smallScroll = sScroll;

                //return(lineScrollSize);

        }

        function get lineScrollSize() {

                return(smallScroll);

        }

        function get virtualHeight() {

                return(__height);

        }

        function init(Void) {

                super.init();

                _scrollPosition = 0;

                tabEnabled = false;

                focusEnabled = false;

                boundingBox_mc._visible = false;

                boundingBox_mc._width = (boundingBox_mc._height = 0);

        }

        function createChildren(Void) {

                if (scrollTrack_mc == undefined) {

                        setSkin(skinIDTrack, scrollTrackName);

                }

                scrollTrack_mc.visible = false;

                var _local3 = new Object();

                _local3.enabled = false;

                _local3.preset = mx.controls.SimpleButton.falseDisabled;

                _local3.initProperties = 0;

                _local3.autoRepeat = true;

                _local3.tabEnabled = false;

                var _local2;

                if (upArrow_mc == undefined) {

                        _local2 = createButton(upArrowName, "upArrow_mc", skinIDUpArrow, _local3);

                }

                _local2.buttonDownHandler = onUpArrow;

                _local2.clickHandler = onScrollChanged;

                _minHeight = _local2.height;

                _minWidth = _local2.width;

                if (downArrow_mc == undefined) {

                        _local2 = createButton(downArrowName, "downArrow_mc", skinIDDownArrow, _local3);

                }

                _local2.buttonDownHandler = onDownArrow;

                _local2.clickHandler = onScrollChanged;

                _minHeight = _minHeight + _local2.height;

        }

        function createButton(linkageName, id, skinID, o) {

                if (skinID == skinIDUpArrow) {

                        o.falseUpSkin = upArrowUpName;

                        o.falseDownSkin = upArrowDownName;

                        o.falseOverSkin = upArrowOverName;

                } else {

                        o.falseUpSkin = downArrowUpName;

                        o.falseDownSkin = downArrowDownName;

                        o.falseOverSkin = downArrowOverName;

                }

                var _local3 = createObject(linkageName, id, skinID, o);

                this[id].visible = false;

                this[id].useHandCursor = false;

                return(_local3);

        }

        function createThumb(Void) {

                var _local2 = new Object();

                _local2.validateNow = true;

                _local2.tabEnabled = false;

                _local2.leftSkin = thumbTopName;

                _local2.middleSkin = thumbMiddleName;

                _local2.rightSkin = thumbBottomName;

                _local2.gripSkin = thumbGripName;

                createClassObject(mx.controls.scrollClasses.ScrollThumb, "scrollThumb_mc", skinIDThumb, _local2);

        }

        function setScrollProperties(pSize, mnPos, mxPos, ls) {

                var _local4;

                var _local2 = scrollTrack_mc;

                pageSize = pSize;

                largeScroll = (((ls != undefined) && (ls > 0)) ? (ls) : (pSize));

                minPos = Math.max(mnPos, 0);

                maxPos = Math.max(mxPos, 0);

                _scrollPosition = Math.max(minPos, _scrollPosition);

                _scrollPosition = Math.min(maxPos, _scrollPosition);

                if (((maxPos - minPos) > 0) && (enabled)) {

                        var _local5 = _scrollPosition;

                        if (!initializing) {

                                upArrow_mc.enabled = true;

                                downArrow_mc.enabled = true;

                        }

                        _local2.onPress = (_local2.onDragOver = startTrackScroller);

                        _local2.onRelease = releaseScrolling;

                        _local2.onDragOut = (_local2.stopScrolling = stopScrolling);

                        _local2.onReleaseOutside = releaseScrolling;

                        _local2.useHandCursor = false;

                        if (scrollThumb_mc == undefined) {

                                createThumb();

                        }

                        var _local3 = scrollThumb_mc;

                        if (scrollTrackOverName.length > 0) {

                                _local2.onRollOver = trackOver;

                                _local2.onRollOut = trackOut;

                        }

                        _local4 = (pageSize / ((maxPos - minPos) + pageSize)) * _local2.height;

                        if (_local4 < _local3.minHeight) {

                                if (_local2.height < _local3.minHeight) {

                                        _local3.__set__visible(false);

                                } else {

                                        _local4 = _local3.minHeight;

                                        _local3.__set__visible(true);

                                        _local3.setSize(_minWidth, _local3.minHeight + 0);

                                }

                        } else {

                                _local3.__set__visible(true);

                                _local3.setSize(_minWidth, _local4);

                        }

                        _local3.setRange(upArrow_mc.__get__height() + 0, (virtualHeight - downArrow_mc.__get__height()) - _local3.__get__height(), minPos, maxPos);

                        _local5 = Math.min(_local5, maxPos);

                        scrollPosition = (Math.max(_local5, minPos));

                } else {

                        scrollThumb_mc.__set__visible(false);

                        if (!initializing) {

                                upArrow_mc.enabled = false;

                                downArrow_mc.enabled = false;

                        }

                        delete _local2.onPress;

                        delete _local2.onDragOver;

                        delete _local2.onRelease;

                        delete _local2.onDragOut;

                        delete _local2.onRollOver;

                        delete _local2.onRollOut;

                        delete _local2.onReleaseOutside;

                }

                if (initializing) {

                        scrollThumb_mc.__set__visible(false);

                }

        }

        function setEnabled(enabledFlag) {

                super.setEnabled(enabledFlag);

                setScrollProperties(pageSize, minPos, maxPos, largeScroll);

        }

        function draw(Void) {

                if (initializing) {

                        initializing = false;

                        scrollTrack_mc.visible = true;

                        upArrow_mc.__set__visible(true);

                        downArrow_mc.__set__visible(true);

                }

                this.size();

        }

        function size(Void) {

                if (_height == 1) {

                        return(undefined);

                }

                if (upArrow_mc == undefined) {

                        return(undefined);

                }

                var _local3 = upArrow_mc.__get__height();

                var _local2 = downArrow_mc.__get__height();

                upArrow_mc.move(0, 0);

                var _local4 = scrollTrack_mc;

                _local4._y = _local3;

                _local4._height = (virtualHeight - _local3) - _local2;

                downArrow_mc.move(0, virtualHeight - _local2);

                setScrollProperties(pageSize, minPos, maxPos, largeScroll);

        }

        function dispatchScrollEvent(detail) {

                dispatchEvent({type:"scroll", detail:detail});

        }

        function isScrollBarKey(k) {

                if (k == 36) {

                        if (scrollPosition != 0) {

                                scrollPosition = (0);

                                dispatchScrollEvent(minMode);

                        }

                        return(true);

                }

                if (k == 35) {

                        if (scrollPosition < maxPos) {

                                scrollPosition = (maxPos);

                                dispatchScrollEvent(maxMode);

                        }

                        return(true);

                }

                return(false);

        }

        function scrollIt(inc, mode) {

                var _local3 = smallScroll;

                if (inc != "Line") {

                        _local3 = ((largeScroll == 0) ? (pageSize) : (largeScroll));

                }

                var _local2 = _scrollPosition + (mode * _local3);

                if (_local2 > maxPos) {

                        _local2 = maxPos;

                } else if (_local2 < minPos) {

                        _local2 = minPos;

                }

                if (scrollPosition != _local2) {

                        scrollPosition = (_local2);

                        var _local4 = ((mode < 0) ? (minusMode) : (plusMode));

                        dispatchScrollEvent(inc + _local4);

                }

        }

        function startTrackScroller(Void) {

                _parent.pressFocus();

                if (_parent.scrollTrackDownName.length > 0) {

                        if (_parent.scrollTrackDown_mc == undefined) {

                                _parent.setSkin(skinIDTrackDown, scrollTrackDownName);

                        } else {

                                _parent.scrollTrackDown_mc.visible = true;

                        }

                }

                _parent.trackScroller();

                _parent.scrolling = setInterval(_parent, "scrollInterval", getStyle("repeatDelay"), "Page", -1);

        }

        function scrollInterval(inc, mode) {

                clearInterval(scrolling);

                if (inc == "Page") {

                        trackScroller();

                } else {

                        scrollIt(inc, mode);

                }

                scrolling = setInterval(this, "scrollInterval", getStyle("repeatInterval"), inc, mode);

        }

        function trackScroller(Void) {

                if ((scrollThumb_mc._y + scrollThumb_mc.__get__height()) < _ymouse) {

                        scrollIt("Page", 1);

                } else if (scrollThumb_mc._y > _ymouse) {

                        scrollIt("Page", -1);

                }

        }

        function dispatchScrollChangedEvent(Void) {

                dispatchEvent({type:"scrollChanged"});

        }

        function stopScrolling(Void) {

                clearInterval(_parent.scrolling);

                _parent.scrollTrackDown_mc.visible = false;

        }

        function releaseScrolling(Void) {

                _parent.releaseFocus();

                stopScrolling();

                _parent.dispatchScrollChangedEvent();

        }

        function trackOver(Void) {

                if (_parent.scrollTrackOverName.length > 0) {

                        if (_parent.scrollTrackOver_mc == undefined) {

                                _parent.setSkin(skinIDTrackOver, scrollTrackOverName);

                        } else {

                                _parent.scrollTrackOver_mc.visible = true;

                        }

                }

        }

        function trackOut(Void) {

                _parent.scrollTrackOver_mc.visible = false;

        }

        function onUpArrow(Void) {

                _parent.scrollIt("Line", -1);

        }

        function onDownArrow(Void) {

                _parent.scrollIt("Line", 1);

        }

        function onScrollChanged(Void) {

                _parent.dispatchScrollChangedEvent();

        }

        static var symbolOwner = mx.core.UIComponent;

        var className = "ScrollBar";

        var minPos = 0;

        var maxPos = 0;

        var pageSize = 0;

        var largeScroll = 0;

        var smallScroll = 1;

        var _scrollPosition = 0;

        var scrollTrackName = "ScrollTrack";

        var scrollTrackOverName = "";

        var scrollTrackDownName = "";

        var upArrowName = "BtnUpArrow";

        var upArrowUpName = "ScrollUpArrowUp";

        var upArrowOverName = "ScrollUpArrowOver";

        var upArrowDownName = "ScrollUpArrowDown";

        var downArrowName = "BtnDownArrow";

        var downArrowUpName = "ScrollDownArrowUp";

        var downArrowOverName = "ScrollDownArrowOver";

        var downArrowDownName = "ScrollDownArrowDown";

        var thumbTopName = "ScrollThumbTopUp";

        var thumbMiddleName = "ScrollThumbMiddleUp";

        var thumbBottomName = "ScrollThumbBottomUp";

        var thumbGripName = "ScrollThumbGripUp";

        static var skinIDTrack = 0;

        static var skinIDTrackOver = 1;

        static var skinIDTrackDown = 2;

        static var skinIDUpArrow = 3;

        static var skinIDDownArrow = 4;

        static var skinIDThumb = 5;

        var idNames = new Array("scrollTrack_mc", "scrollTrackOver_mc", "scrollTrackDown_mc", "upArrow_mc", "downArrow_mc");

        var clipParameters = {minPos:1, maxPos:1, pageSize:1, scrollPosition:1, lineScrollSize:1, pageScrollSize:1, visible:1, enabled:1};

        static var mergedClipParameters = mx.core.UIObject.mergeClipParameters(mx.controls.scrollClasses.ScrollBar.prototype.clipParameters, mx.core.UIComponent.prototype.clipParameters);

        var initializing = true;

}