MyGUI  3.2.1
MyGUI_ScrollView.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_ScrollView.h"
00009 #include "MyGUI_SkinManager.h"
00010 #include "MyGUI_ISubWidgetText.h"
00011 #include "MyGUI_ScrollBar.h"
00012 
00013 namespace MyGUI
00014 {
00015 
00016     const int SCROLL_VIEW_MOUSE_WHEEL = 50; // колличество пикселей для колеса мыши
00017     const int SCROLL_VIEW_SCROLL_PAGE = 16; // колличество пикселей для кнопок скрола
00018 
00019     ScrollView::ScrollView() :
00020         mContentAlign(Align::Center),
00021         mRealClient(nullptr)
00022     {
00023         mChangeContentByResize = false;
00024     }
00025 
00026     void ScrollView::initialiseOverride()
00027     {
00028         Base::initialiseOverride();
00029 
00030         // FIXME нам нужен фокус клавы
00031         setNeedKeyFocus(true);
00032 
00034         assignWidget(mClient, "Client");
00035         MyGUI::Widget* realClientOwner = this;
00036         if (mClient != nullptr)
00037         {
00038             mClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
00039             realClientOwner = mClient;
00040         }
00041 
00042         // создаем холcт, реальный владелец детей
00043         mRealClient = realClientOwner->createWidget<Widget>("Default", IntCoord(), Align::Default);
00044         mRealClient->eventMouseWheel += newDelegate(this, &ScrollView::notifyMouseWheel);
00045         setWidgetClient(mRealClient);
00046 
00048         assignWidget(mVScroll, "VScroll");
00049         if (mVScroll != nullptr)
00050         {
00051             mVScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
00052         }
00053 
00055         assignWidget(mHScroll, "HScroll");
00056         if (mHScroll != nullptr)
00057         {
00058             mHScroll->eventScrollChangePosition += newDelegate(this, &ScrollView::notifyScrollChangePosition);
00059         }
00060 
00061         updateView();
00062     }
00063 
00064     void ScrollView::shutdownOverride()
00065     {
00066         mVScroll = nullptr;
00067         mHScroll = nullptr;
00068         mClient = nullptr;
00069         mRealClient = nullptr;
00070 
00071         Base::shutdownOverride();
00072     }
00073 
00074     void ScrollView::setPosition(const IntPoint& _point)
00075     {
00076         Base::setPosition(_point);
00077     }
00078 
00079     void ScrollView::setSize(const IntSize& _size)
00080     {
00081         Base::setSize(_size);
00082 
00083         updateView();
00084     }
00085 
00086     void ScrollView::setCoord(const IntCoord& _coord)
00087     {
00088         Base::setCoord(_coord);
00089 
00090         updateView();
00091     }
00092 
00093     void ScrollView::notifyScrollChangePosition(ScrollBar* _sender, size_t _position)
00094     {
00095         if (mRealClient == nullptr)
00096             return;
00097 
00098         if (_sender == mVScroll)
00099         {
00100             IntPoint point = mRealClient->getPosition();
00101             point.top = -(int)_position;
00102             mRealClient->setPosition(point);
00103         }
00104         else if (_sender == mHScroll)
00105         {
00106             IntPoint point = mRealClient->getPosition();
00107             point.left = -(int)_position;
00108             mRealClient->setPosition(point);
00109         }
00110     }
00111 
00112     void ScrollView::notifyMouseWheel(Widget* _sender, int _rel)
00113     {
00114         if (mRealClient == nullptr)
00115             return;
00116 
00117         if (mVRange != 0)
00118         {
00119             IntPoint point = mRealClient->getPosition();
00120             int offset = -point.top;
00121             if (_rel < 0) offset += SCROLL_VIEW_MOUSE_WHEEL;
00122             else  offset -= SCROLL_VIEW_MOUSE_WHEEL;
00123 
00124             if (offset < 0) offset = 0;
00125             else if (offset > (int)mVRange) offset = mVRange;
00126 
00127             if (offset != point.top)
00128             {
00129                 point.top = -offset;
00130                 if (mVScroll != nullptr)
00131                 {
00132                     mVScroll->setScrollPosition(offset);
00133                 }
00134                 mRealClient->setPosition(point);
00135             }
00136         }
00137         else if (mHRange != 0)
00138         {
00139             IntPoint point = mRealClient->getPosition();
00140             int offset = -point.left;
00141             if (_rel < 0) offset += SCROLL_VIEW_MOUSE_WHEEL;
00142             else  offset -= SCROLL_VIEW_MOUSE_WHEEL;
00143 
00144             if (offset < 0) offset = 0;
00145             else if (offset > (int)mHRange) offset = mHRange;
00146 
00147             if (offset != point.left)
00148             {
00149                 point.left = -offset;
00150                 if (mHScroll != nullptr)
00151                 {
00152                     mHScroll->setScrollPosition(offset);
00153                 }
00154                 mRealClient->setPosition(point);
00155             }
00156         }
00157     }
00158 
00159     IntSize ScrollView::getContentSize()
00160     {
00161         return mRealClient == nullptr ? IntSize() : mRealClient->getSize();
00162     }
00163 
00164     IntPoint ScrollView::getContentPosition()
00165     {
00166         return mRealClient == nullptr ? IntPoint() : (IntPoint() - mRealClient->getPosition());
00167     }
00168 
00169     void ScrollView::setContentPosition(const IntPoint& _point)
00170     {
00171         if (mRealClient != nullptr)
00172             mRealClient->setPosition(IntPoint() - _point);
00173     }
00174 
00175     IntSize ScrollView::getViewSize()
00176     {
00177         return mClient == nullptr ? getSize() : mClient->getSize();
00178     }
00179 
00180     size_t ScrollView::getVScrollPage()
00181     {
00182         return SCROLL_VIEW_SCROLL_PAGE;
00183     }
00184 
00185     size_t ScrollView::getHScrollPage()
00186     {
00187         return SCROLL_VIEW_SCROLL_PAGE;
00188     }
00189 
00190     void ScrollView::updateView()
00191     {
00192         updateScrollSize();
00193         updateScrollPosition();
00194     }
00195 
00196     void ScrollView::setVisibleVScroll(bool _value)
00197     {
00198         mVisibleVScroll = _value;
00199         updateView();
00200     }
00201 
00202     void ScrollView::setVisibleHScroll(bool _value)
00203     {
00204         mVisibleHScroll = _value;
00205         updateView();
00206     }
00207 
00208     void ScrollView::setCanvasAlign(Align _value)
00209     {
00210         mContentAlign = _value;
00211         updateView();
00212     }
00213 
00214     void ScrollView::setCanvasSize(const IntSize& _value)
00215     {
00216         if (mRealClient != nullptr)
00217             mRealClient->setSize(_value);
00218         updateView();
00219     }
00220 
00221     IntSize ScrollView::getCanvasSize()
00222     {
00223         return mRealClient == nullptr ? IntSize() : mRealClient->getSize();
00224     }
00225 
00226     void ScrollView::setPropertyOverride(const std::string& _key, const std::string& _value)
00227     {
00229         if (_key == "VisibleVScroll")
00230             setVisibleVScroll(utility::parseValue<bool>(_value));
00231 
00233         else if (_key == "VisibleHScroll")
00234             setVisibleHScroll(utility::parseValue<bool>(_value));
00235 
00237         else if (_key == "CanvasAlign")
00238             setCanvasAlign(utility::parseValue<Align>(_value));
00239 
00241         else if (_key == "CanvasSize")
00242             setCanvasSize(utility::parseValue<IntSize>(_value));
00243 
00244         else
00245         {
00246             Base::setPropertyOverride(_key, _value);
00247             return;
00248         }
00249 
00250         eventChangeProperty(this, _key, _value);
00251     }
00252 
00253     void ScrollView::setPosition(int _left, int _top)
00254     {
00255         setPosition(IntPoint(_left, _top));
00256     }
00257 
00258     void ScrollView::setSize(int _width, int _height)
00259     {
00260         setSize(IntSize(_width, _height));
00261     }
00262 
00263     void ScrollView::setCoord(int _left, int _top, int _width, int _height)
00264     {
00265         setCoord(IntCoord(_left, _top, _width, _height));
00266     }
00267 
00268     bool ScrollView::isVisibleVScroll() const
00269     {
00270         return mVisibleVScroll;
00271     }
00272 
00273     bool ScrollView::isVisibleHScroll() const
00274     {
00275         return mVisibleHScroll;
00276     }
00277 
00278     Align ScrollView::getCanvasAlign() const
00279     {
00280         return mContentAlign;
00281     }
00282 
00283     void ScrollView::setCanvasSize(int _width, int _height)
00284     {
00285         setCanvasSize(IntSize(_width, _height));
00286     }
00287 
00288     Align ScrollView::getContentAlign()
00289     {
00290         return mContentAlign;
00291     }
00292 
00293     void ScrollView::setViewOffset(const IntPoint& _value)
00294     {
00295         IntPoint value = _value;
00296         IntPoint currentOffset = mRealClient->getPosition();
00297 
00298         if (mHRange != 0)
00299         {
00300             if (value.left > 0)
00301                 value.left = 0;
00302             else if (value.left < -(int)mHRange)
00303                 value.left = -(int)mHRange;
00304         }
00305         else
00306         {
00307             value.left = currentOffset.left;
00308         }
00309 
00310         if (mVRange != 0)
00311         {
00312             if (value.top > 0)
00313                 value.top = 0;
00314             else if (value.top < -(int)mVRange)
00315                 value.top = -(int)mVRange;
00316         }
00317         else
00318         {
00319             value.top = currentOffset.top;
00320         }
00321 
00322         if (mHScroll != nullptr)
00323             mHScroll->setScrollPosition(-value.left);
00324 
00325         if (mVScroll != nullptr)
00326             mVScroll->setScrollPosition(-value.top);
00327 
00328         mRealClient->setPosition(value);
00329     }
00330 
00331     IntPoint ScrollView::getViewOffset() const
00332     {
00333         return mRealClient->getPosition();
00334     }
00335 
00336     IntCoord ScrollView::getViewCoord() const
00337     {
00338         return mClient == nullptr ? getCoord() : mClient->getCoord();
00339     }
00340 
00341     ScrollBar* ScrollView::getVScroll()
00342     {
00343         return mVScroll;
00344     }
00345 
00346 } // namespace MyGUI