MyGUI  3.2.1
MyGUI_ScrollBar.cpp
Go to the documentation of this file.
00001 /*
00002  * This source file is part of MyGUI. For the latest info, see http://mygui.info/
00003  * Distributed under the MIT License
00004  * (See accompanying file COPYING.MIT or copy at http://opensource.org/licenses/MIT)
00005  */
00006 
00007 #include "MyGUI_Precompiled.h"
00008 #include "MyGUI_ScrollBar.h"
00009 #include "MyGUI_InputManager.h"
00010 #include "MyGUI_Button.h"
00011 #include "MyGUI_ResourceSkin.h"
00012 #include "MyGUI_ControllerRepeatClick.h"
00013 #include "MyGUI_ControllerManager.h"
00014 
00015 namespace MyGUI
00016 {
00017 
00018     ScrollBar::ScrollBar() :
00019         mWidgetStart(nullptr),
00020         mWidgetEnd(nullptr),
00021         mWidgetTrack(nullptr),
00022         mWidgetFirstPart(nullptr),
00023         mWidgetSecondPart(nullptr),
00024         mSkinRangeStart(0),
00025         mSkinRangeEnd(0),
00026         mScrollRange(0),
00027         mScrollPosition(0),
00028         mScrollPage(0),
00029         mScrollViewPage(0),
00030         mScrollWheelPage(0),
00031         mMinTrackSize(0),
00032         mMoveToClick(false),
00033         mVerticalAlignment(true),
00034         mEnableRepeat(true),
00035         mRepeatTriggerTime(0.f),
00036         mRepeatStepTime(0.f)
00037     {
00038     }
00039 
00040     void ScrollBar::initialiseOverride()
00041     {
00042         Base::initialiseOverride();
00043 
00044         // при нуле, будет игнорировать кнопки
00045         mScrollPage = 1;
00046         mScrollViewPage = 1;
00047         mScrollWheelPage = 1;
00048         mMinTrackSize = 0;
00049         mSkinRangeStart = 0;
00050         mSkinRangeEnd = 0;
00051 
00052         mRepeatTriggerTime = 0.5;
00053         mRepeatStepTime = 0.1;
00054 
00056         assignWidget(mWidgetStart, "Start");
00057         if (mWidgetStart != nullptr)
00058         {
00059             mWidgetStart->eventMouseButtonPressed += newDelegate(this, &ScrollBar::notifyMousePressed);
00060             mWidgetStart->eventMouseButtonReleased += newDelegate(this, &ScrollBar::notifyMouseReleased);
00061             mWidgetStart->eventMouseWheel += newDelegate(this, &ScrollBar::notifyMouseWheel);
00062         }
00063 
00065         assignWidget(mWidgetEnd, "End");
00066         if (mWidgetEnd != nullptr)
00067         {
00068             mWidgetEnd->eventMouseButtonPressed += newDelegate(this, &ScrollBar::notifyMousePressed);
00069             mWidgetEnd->eventMouseButtonReleased += newDelegate(this, &ScrollBar::notifyMouseReleased);
00070             mWidgetEnd->eventMouseWheel += newDelegate(this, &ScrollBar::notifyMouseWheel);
00071         }
00072 
00074         assignWidget(mWidgetTrack, "Track");
00075         if (mWidgetTrack)
00076         {
00077             mWidgetTrack->eventMouseDrag += newDelegate(this, &ScrollBar::notifyMouseDrag);
00078             mWidgetTrack->eventMouseButtonPressed += newDelegate(this, &ScrollBar::notifyMousePressed);
00079             mWidgetTrack->eventMouseButtonReleased += newDelegate(this, &ScrollBar::notifyMouseReleased);
00080             mWidgetTrack->eventMouseWheel += newDelegate(this, &ScrollBar::notifyMouseWheel);
00081             mWidgetTrack->setVisible(false);
00082         }
00083 
00085         assignWidget(mWidgetFirstPart, "FirstPart");
00086         if (mWidgetFirstPart != nullptr)
00087         {
00088             mWidgetFirstPart->eventMouseButtonPressed += newDelegate(this, &ScrollBar::notifyMousePressed);
00089             mWidgetFirstPart->eventMouseButtonReleased += newDelegate(this, &ScrollBar::notifyMouseReleased);
00090             mWidgetFirstPart->eventMouseWheel += newDelegate(this, &ScrollBar::notifyMouseWheel);
00091         }
00092 
00094         assignWidget(mWidgetSecondPart, "SecondPart");
00095         if (mWidgetSecondPart != nullptr)
00096         {
00097             mWidgetSecondPart->eventMouseButtonPressed += newDelegate(this, &ScrollBar::notifyMousePressed);
00098             mWidgetSecondPart->eventMouseButtonReleased += newDelegate(this, &ScrollBar::notifyMouseReleased);
00099             mWidgetSecondPart->eventMouseWheel += newDelegate(this, &ScrollBar::notifyMouseWheel);
00100         }
00101 
00102         if (isUserString("MinTrackSize"))
00103             mMinTrackSize = utility::parseValue<int>(getUserString("MinTrackSize"));
00104 
00105         if (isUserString("TrackRangeMargins"))
00106             utility::parseComplex<size_t>(getUserString("TrackRangeMargins"), mSkinRangeStart, mSkinRangeEnd);
00107 
00108         if (mWidgetTrack != nullptr)
00109         {
00110             if (mWidgetTrack->isUserString("MinTrackSize"))
00111                 mMinTrackSize = utility::parseValue<int>(mWidgetTrack->getUserString("MinTrackSize"));
00112         }
00113     }
00114 
00115     void ScrollBar::shutdownOverride()
00116     {
00117         mWidgetStart = nullptr;
00118         mWidgetEnd = nullptr;
00119         mWidgetTrack = nullptr;
00120         mWidgetFirstPart = nullptr;
00121         mWidgetSecondPart = nullptr;
00122 
00123         Base::shutdownOverride();
00124     }
00125 
00126     void ScrollBar::updateTrack()
00127     {
00128         if (mWidgetTrack == nullptr)
00129             return;
00130 
00131         _forcePick(mWidgetTrack);
00132         // размер диапазана в пикселях
00133         int pos = getLineSize();
00134 
00135         if (mVerticalAlignment)
00136         {
00137             // скрываем если диапазан маленький или места мало
00138             if ((mScrollRange < 2) || (pos <= mWidgetTrack->getHeight()))
00139             {
00140                 mWidgetTrack->setVisible(false);
00141                 if (nullptr != mWidgetFirstPart)
00142                     mWidgetFirstPart->setSize(mWidgetFirstPart->getWidth(), pos / 2);
00143                 if (nullptr != mWidgetSecondPart)
00144                     mWidgetSecondPart->setCoord(mWidgetSecondPart->getLeft(), pos / 2 + (int)mSkinRangeStart, mWidgetSecondPart->getWidth(), pos - pos / 2);
00145                 return;
00146             }
00147             // если скрыт то покажем
00148             if (!mWidgetTrack->getVisible())
00149                 mWidgetTrack->setVisible(true);
00150 
00151             // и обновляем позицию
00152             pos = (int)(((size_t)(pos - getTrackSize()) * mScrollPosition) / (mScrollRange - 1) + mSkinRangeStart);
00153 
00154             mWidgetTrack->setPosition(mWidgetTrack->getLeft(), pos);
00155             if (nullptr != mWidgetFirstPart)
00156             {
00157                 int height = pos - mWidgetFirstPart->getTop();
00158                 mWidgetFirstPart->setSize(mWidgetFirstPart->getWidth(), height);
00159             }
00160             if (nullptr != mWidgetSecondPart)
00161             {
00162                 int top = pos + mWidgetTrack->getHeight();
00163                 int height = mWidgetSecondPart->getHeight() + mWidgetSecondPart->getTop() - top;
00164                 mWidgetSecondPart->setCoord(mWidgetSecondPart->getLeft(), top, mWidgetSecondPart->getWidth(), height);
00165             }
00166         }
00167         else
00168         {
00169             // скрываем если диапазан маленький или места мало
00170             if ((mScrollRange < 2) || (pos <= mWidgetTrack->getWidth()))
00171             {
00172                 mWidgetTrack->setVisible(false);
00173                 if (nullptr != mWidgetFirstPart)
00174                     mWidgetFirstPart->setSize(pos / 2, mWidgetFirstPart->getHeight());
00175                 if (nullptr != mWidgetSecondPart)
00176                     mWidgetSecondPart->setCoord(pos / 2 + (int)mSkinRangeStart, mWidgetSecondPart->getTop(), pos - pos / 2, mWidgetSecondPart->getHeight());
00177                 return;
00178             }
00179             // если скрыт то покажем
00180             if (!mWidgetTrack->getVisible())
00181                 mWidgetTrack->setVisible(true);
00182 
00183             // и обновляем позицию
00184             pos = (int)(((size_t)(pos - getTrackSize()) * mScrollPosition) / (mScrollRange - 1) + mSkinRangeStart);
00185 
00186             mWidgetTrack->setPosition(pos, mWidgetTrack->getTop());
00187             if (nullptr != mWidgetFirstPart)
00188             {
00189                 int height = pos - mWidgetFirstPart->getLeft();
00190                 mWidgetFirstPart->setSize(height, mWidgetFirstPart->getHeight());
00191             }
00192             if (nullptr != mWidgetSecondPart)
00193             {
00194                 int top = pos + mWidgetTrack->getWidth();
00195                 int height = mWidgetSecondPart->getWidth() + mWidgetSecondPart->getLeft() - top;
00196                 mWidgetSecondPart->setCoord(top, mWidgetSecondPart->getTop(), height, mWidgetSecondPart->getHeight());
00197             }
00198         }
00199     }
00200 
00201     void ScrollBar::TrackMove(int _left, int _top)
00202     {
00203         if (mWidgetTrack == nullptr)
00204             return;
00205 
00206         const IntPoint& point = InputManager::getInstance().getLastPressedPosition(MouseButton::Left);
00207 
00208         if (mVerticalAlignment)
00209         {
00210             // расчитываем позицию виджета
00211             int start = mPreActionOffset.top + (_top - point.top);
00212             if (start < (int)mSkinRangeStart)
00213                 start = (int)mSkinRangeStart;
00214             else if (start > (getTrackPlaceLength() - (int)mSkinRangeEnd - mWidgetTrack->getHeight()))
00215                 start = (getTrackPlaceLength() - (int)mSkinRangeEnd - mWidgetTrack->getHeight());
00216             if (mWidgetTrack->getTop() != start)
00217                 mWidgetTrack->setPosition(mWidgetTrack->getLeft(), start);
00218 
00219             // расчитываем положение соответствующее позиции
00220             // плюс пол позиции
00221             int pos = start - (int)mSkinRangeStart + (getLineSize() - getTrackSize()) / (((int)mScrollRange - 1) * 2);
00222             // высчитываем ближайшее значение и обновляем
00223             pos = pos * (int)(mScrollRange - 1) / (getLineSize() - getTrackSize());
00224 
00225             // проверяем на выходы и изменения
00226             if (pos < 0)
00227                 pos = 0;
00228             else if (pos >= (int)mScrollRange)
00229                 pos = (int)mScrollRange - 1;
00230             if (pos == (int)mScrollPosition)
00231                 return;
00232 
00233             mScrollPosition = pos;
00234         }
00235         else
00236         {
00237             // расчитываем позицию виджета
00238             int start = mPreActionOffset.left + (_left - point.left);
00239             if (start < (int)mSkinRangeStart)
00240                 start = (int)mSkinRangeStart;
00241             else if (start > (getTrackPlaceLength() - (int)mSkinRangeEnd - mWidgetTrack->getWidth()))
00242                 start = (getTrackPlaceLength() - (int)mSkinRangeEnd - mWidgetTrack->getWidth());
00243             if (mWidgetTrack->getLeft() != start)
00244                 mWidgetTrack->setPosition(IntPoint(start, mWidgetTrack->getTop()));
00245 
00246             // расчитываем положение соответствующее позиции
00247             // плюс пол позиции
00248             int pos = start - (int)mSkinRangeStart + (getLineSize() - getTrackSize()) / (((int)mScrollRange - 1) * 2);
00249             // высчитываем ближайшее значение и обновляем
00250             pos = pos * (int)(mScrollRange - 1) / (getLineSize() - getTrackSize());
00251 
00252             // проверяем на выходы и изменения
00253             if (pos < 0)
00254                 pos = 0;
00255             else if (pos >= (int)mScrollRange)
00256                 pos = (int)mScrollRange - 1;
00257             if (pos == (int)mScrollPosition)
00258                 return;
00259 
00260             mScrollPosition = pos;
00261         }
00262 
00263         updateTrack();
00264 
00265         // отсылаем событие
00266         eventScrollChangePosition(this, (int)mScrollPosition);
00267     }
00268 
00269     void ScrollBar::notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id)
00270     {
00271         // диспечерезируем нажатие своих детей как свое
00272         eventMouseButtonPressed(this, _left, _top, _id);
00273 
00274         if (MouseButton::Left != _id)
00275             return;
00276 
00277         if (mEnableRepeat && _sender != mWidgetTrack)
00278         {
00279             ControllerItem* item = ControllerManager::getInstance().createItem(ControllerRepeatClick::getClassTypeName());
00280             ControllerRepeatClick* controller = item->castType<ControllerRepeatClick>();
00281             controller->eventRepeatClick += newDelegate(this, &ScrollBar::repeatClick);
00282             controller->setRepeat(mRepeatTriggerTime, mRepeatStepTime);
00283             ControllerManager::getInstance().addItem(_sender, controller);
00284         }
00285 
00286         if (mMoveToClick &&
00287             _sender != mWidgetTrack &&
00288             _sender != mWidgetStart &&
00289             _sender != mWidgetEnd)
00290         {
00291             if (mWidgetTrack != nullptr)
00292             {
00293                 mPreActionOffset = InputManager::getInstance().getLastPressedPosition(MouseButton::Left);
00294                 const IntPoint& point = InputManager::getInstance().getMousePositionByLayer() - mWidgetTrack->getParent()->getAbsolutePosition();
00295 
00296                 mPreActionOffset.left -= getTrackSize() / 2;
00297                 mPreActionOffset.top -= getTrackSize() / 2;
00298 
00299                 TrackMove(point.left, point.top);
00300             }
00301         }
00302         else if (_sender == mWidgetStart)
00303         {
00304             widgetStartPressed();
00305         }
00306         else if (_sender == mWidgetEnd)
00307         {
00308             widgetEndPressed();
00309         }
00310         else if (_sender == mWidgetFirstPart)
00311         {
00312             widgetFirstPartPressed();
00313         }
00314         else if (_sender == mWidgetSecondPart)
00315         {
00316             widgetSecondPartPressed();
00317         }
00318         else if (_sender == mWidgetTrack)
00319         {
00320             mPreActionOffset.left = _sender->getLeft();
00321             mPreActionOffset.top = _sender->getTop();
00322         }
00323     }
00324 
00325     void ScrollBar::notifyMouseReleased(Widget* _sender, int _left, int _top, MouseButton _id)
00326     {
00327         updateTrack();
00328         MyGUI::ControllerManager::getInstance().removeItem(_sender);
00329     }
00330 
00331     void ScrollBar::notifyMouseDrag(Widget* _sender, int _left, int _top, MouseButton _id)
00332     {
00333         if (_id == MouseButton::Left)
00334             TrackMove(_left, _top);
00335     }
00336 
00337     void ScrollBar::setScrollRange(size_t _range)
00338     {
00339         if (_range == mScrollRange)
00340             return;
00341 
00342         mScrollRange = _range;
00343         mScrollPosition = (mScrollPosition < mScrollRange) ? mScrollPosition : 0;
00344         updateTrack();
00345     }
00346 
00347     void ScrollBar::setScrollPosition(size_t _position)
00348     {
00349         if (_position == mScrollPosition)
00350             return;
00351 
00352         if (_position >= mScrollRange)
00353             _position = 0;
00354 
00355         mScrollPosition = _position;
00356         updateTrack();
00357     }
00358 
00359     void ScrollBar::setPosition(const IntPoint& _point)
00360     {
00361         Base::setPosition(_point);
00362     }
00363 
00364     void ScrollBar::setSize(const IntSize& _size)
00365     {
00366         Base::setSize(_size);
00367         // обновляем трек
00368         updateTrack();
00369     }
00370 
00371     void ScrollBar::setCoord(const IntCoord& _coord)
00372     {
00373         Base::setCoord(_coord);
00374         // обновляем трек
00375         updateTrack();
00376     }
00377 
00378     void ScrollBar::setTrackSize(int _size)
00379     {
00380         if (mWidgetTrack != nullptr)
00381         {
00382             if (mVerticalAlignment)
00383                 mWidgetTrack->setSize(mWidgetTrack->getWidth(), ((int)_size < (int)mMinTrackSize) ? (int)mMinTrackSize : (int)_size);
00384             else
00385                 mWidgetTrack->setSize(((int)_size < (int)mMinTrackSize) ? (int)mMinTrackSize : (int)_size, mWidgetTrack->getHeight());
00386         }
00387         updateTrack();
00388     }
00389 
00390     void ScrollBar::setRepeatTriggerTime(float time)
00391     {
00392         mRepeatTriggerTime = time;
00393     }
00394 
00395     void ScrollBar::setRepeatStepTime(float time)
00396     {
00397         mRepeatStepTime = time;
00398     }
00399 
00400     float ScrollBar::getRepeatTriggerTime(float time) const
00401     {
00402         return mRepeatTriggerTime;
00403     }
00404 
00405     float ScrollBar::getRepeatStepTime(float time) const
00406     {
00407         return mRepeatStepTime;
00408     }
00409 
00410     void ScrollBar::setRepeatEnabled(bool enabled)
00411     {
00412         mEnableRepeat = enabled;
00413     }
00414 
00415     bool ScrollBar::getRepeatEnabled() const
00416     {
00417         return mEnableRepeat;
00418     }
00419 
00420     int ScrollBar::getTrackSize() const
00421     {
00422         if (mWidgetTrack != nullptr)
00423         {
00424             if (mVerticalAlignment)
00425                 return mWidgetTrack->getHeight();
00426             else
00427                 return mWidgetTrack->getWidth();
00428         }
00429         return 1;
00430     }
00431 
00432     int ScrollBar::getLineSize() const
00433     {
00434         return getTrackPlaceLength() - (int)(mSkinRangeStart + mSkinRangeEnd);
00435     }
00436 
00437     void ScrollBar::onMouseWheel(int _rel)
00438     {
00439         notifyMouseWheel(nullptr, _rel);
00440 
00441         Base::onMouseWheel(_rel);
00442     }
00443 
00444     void ScrollBar::notifyMouseWheel(Widget* _sender, int _rel)
00445     {
00446         if (mScrollRange < 2)
00447             return;
00448 
00449         int offset = mScrollPosition;
00450         if (_rel < 0)
00451             offset += mScrollWheelPage;
00452         else
00453             offset -= mScrollWheelPage;
00454 
00455         if (offset < 0)
00456             offset = 0;
00457         else if (offset > (int)(mScrollRange - 1))
00458             offset = mScrollRange - 1;
00459 
00460         if ((size_t)offset != mScrollPosition)
00461         {
00462             mScrollPosition = offset;
00463             // оповещаем
00464             eventScrollChangePosition(this, (int)mScrollPosition);
00465             updateTrack();
00466         }
00467     }
00468 
00469     void ScrollBar::repeatClick(Widget *_widget, ControllerItem *_controller)
00470     {
00471         if (_widget == mWidgetStart)
00472             widgetStartPressed();
00473         else if (_widget == mWidgetEnd)
00474             widgetEndPressed();
00475         else if (_widget == mWidgetFirstPart)
00476             widgetFirstPartPressed();
00477         else if (_widget == mWidgetSecondPart)
00478             widgetSecondPartPressed();
00479     }
00480 
00481     void ScrollBar::widgetStartPressed()
00482     {
00483         // минимальное значение
00484         if (mScrollPosition == 0)
00485             return;
00486 
00487         // расчитываем следующее положение
00488         if (mScrollPosition > mScrollPage)
00489             mScrollPosition -= mScrollPage;
00490         else
00491             mScrollPosition = 0;
00492 
00493         // оповещаем
00494         eventScrollChangePosition(this, (int)mScrollPosition);
00495         updateTrack();
00496     }
00497 
00498     void ScrollBar::widgetEndPressed()
00499     {
00500         // максимальное значение
00501         if ((mScrollRange < 2) || (mScrollPosition >= (mScrollRange - 1)))
00502             return;
00503 
00504         // расчитываем следующее положение
00505         if ((mScrollPosition + mScrollPage) < (mScrollRange - 1))
00506             mScrollPosition += mScrollPage;
00507         else
00508             mScrollPosition = mScrollRange - 1;
00509 
00510         // оповещаем
00511         eventScrollChangePosition(this, (int)mScrollPosition);
00512         updateTrack();
00513     }
00514 
00515     void ScrollBar::widgetFirstPartPressed()
00516     {
00517         // минимальное значение
00518         if (mScrollPosition == 0)
00519             return;
00520 
00521         // расчитываем следующее положение
00522         if (mScrollPosition > mScrollViewPage)
00523             mScrollPosition -= mScrollViewPage;
00524         else
00525             mScrollPosition = 0;
00526 
00527         // оповещаем
00528         eventScrollChangePosition(this, (int)mScrollPosition);
00529         updateTrack();
00530     }
00531 
00532     void ScrollBar::widgetSecondPartPressed()
00533     {
00534         // максимальное значение
00535         if ((mScrollRange < 2) || (mScrollPosition >= (mScrollRange - 1)))
00536             return;
00537 
00538         // расчитываем следующее положение
00539         if ((mScrollPosition + mScrollViewPage) < (mScrollRange - 1))
00540             mScrollPosition += mScrollViewPage;
00541         else
00542             mScrollPosition = mScrollRange - 1;
00543 
00544         // оповещаем
00545         eventScrollChangePosition(this, (int)mScrollPosition);
00546         updateTrack();
00547     }
00548 
00549     void ScrollBar::setPropertyOverride(const std::string& _key, const std::string& _value)
00550     {
00552         if (_key == "Range")
00553             setScrollRange(utility::parseValue<size_t>(_value));
00554 
00556         else if (_key == "RangePosition")
00557             setScrollPosition(utility::parseValue<size_t>(_value));
00558 
00560         else if (_key == "Page")
00561             setScrollPage(utility::parseValue<size_t>(_value));
00562 
00564         else if (_key == "ViewPage")
00565             setScrollViewPage(utility::parseValue<size_t>(_value));
00566 
00568         else if (_key == "WheelPage")
00569             setScrollWheelPage(utility::parseValue<size_t>(_value));
00570 
00572         else if (_key == "MoveToClick")
00573             setMoveToClick(utility::parseValue<bool>(_value));
00574 
00576         else if (_key == "VerticalAlignment")
00577             setVerticalAlignment(utility::parseValue<bool>(_value));
00578 
00580         else if (_key == "Repeat")
00581             setRepeatEnabled(utility::parseValue<bool>(_value));
00582 
00584         else if (_key == "RepeatTriggerTime")
00585             setRepeatTriggerTime(utility::parseValue<float>(_value));
00586 
00588         else if (_key == "RepeatStepTime")
00589             setRepeatStepTime(utility::parseValue<float>(_value));
00590 
00591         else
00592         {
00593             Base::setPropertyOverride(_key, _value);
00594             return;
00595         }
00596 
00597         eventChangeProperty(this, _key, _value);
00598     }
00599 
00600     size_t ScrollBar::getScrollRange() const
00601     {
00602         return mScrollRange;
00603     }
00604 
00605     size_t ScrollBar::getScrollPosition() const
00606     {
00607         return mScrollPosition;
00608     }
00609 
00610     void ScrollBar::setScrollPage(size_t _value)
00611     {
00612         mScrollPage = _value;
00613     }
00614 
00615     size_t ScrollBar::getScrollPage() const
00616     {
00617         return mScrollPage;
00618     }
00619 
00620     void ScrollBar::setScrollViewPage(size_t _value)
00621     {
00622         mScrollViewPage = _value;
00623     }
00624 
00625     size_t ScrollBar::getScrollViewPage() const
00626     {
00627         return mScrollViewPage;
00628     }
00629 
00630     void ScrollBar::setScrollWheelPage(size_t _value)
00631     {
00632         mScrollWheelPage = _value;
00633     }
00634     size_t ScrollBar::getScrollWheelPage() const
00635     {
00636         return mScrollWheelPage;
00637     }
00638 
00639     void ScrollBar::setMinTrackSize(int _value)
00640     {
00641         mMinTrackSize = _value;
00642     }
00643 
00644     int ScrollBar::getMinTrackSize() const
00645     {
00646         return mMinTrackSize;
00647     }
00648 
00649     void ScrollBar::setMoveToClick(bool _value)
00650     {
00651         mMoveToClick = _value;
00652     }
00653 
00654     bool ScrollBar::getMoveToClick() const
00655     {
00656         return mMoveToClick;
00657     }
00658 
00659     void ScrollBar::setPosition(int _left, int _top)
00660     {
00661         setPosition(IntPoint(_left, _top));
00662     }
00663 
00664     void ScrollBar::setSize(int _width, int _height)
00665     {
00666         setSize(IntSize(_width, _height));
00667     }
00668 
00669     void ScrollBar::setCoord(int _left, int _top, int _width, int _height)
00670     {
00671         setCoord(IntCoord(_left, _top, _width, _height));
00672     }
00673 
00674     int ScrollBar::getTrackPlaceLength() const
00675     {
00676         if (mWidgetTrack != nullptr)
00677         {
00678             if (mVerticalAlignment)
00679                 return mWidgetTrack->getParent()->getHeight();
00680             else
00681                 return mWidgetTrack->getParent()->getWidth();
00682         }
00683         return 0;
00684     }
00685 
00686     void ScrollBar::setVerticalAlignment(bool _value)
00687     {
00688         mVerticalAlignment = _value;
00689 
00690         updateTrack();
00691     }
00692 
00693     bool ScrollBar::getVerticalAlignment() const
00694     {
00695         return mVerticalAlignment;
00696     }
00697 
00698 } // namespace MyGUI