MyGUI  3.2.1
MyGUI_BackwardCompatibility.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_BackwardCompatibility.h"
00009 #include "MyGUI_Button.h"
00010 #include "MyGUI_ComboBox.h"
00011 #include "MyGUI_EditBox.h"
00012 #include "MyGUI_ItemBox.h"
00013 #include "MyGUI_ListBox.h"
00014 #include "MyGUI_MenuControl.h"
00015 #include "MyGUI_MenuItem.h"
00016 #include "MyGUI_MultiListBox.h"
00017 #include "MyGUI_ProgressBar.h"
00018 #include "MyGUI_ScrollView.h"
00019 #include "MyGUI_TabControl.h"
00020 #include "MyGUI_Widget.h"
00021 #include "MyGUI_Window.h"
00022 #include "MyGUI_TabItem.h"
00023 #include "MyGUI_Canvas.h"
00024 #include "MyGUI_LayoutManager.h"
00025 #include "MyGUI_FontManager.h"
00026 #include "MyGUI_ResourceManager.h"
00027 #include "MyGUI_Gui.h"
00028 #include "MyGUI_PointerManager.h"
00029 #include "MyGUI_InputManager.h"
00030 #include "MyGUI_RenderManager.h"
00031 #include "MyGUI_LanguageManager.h"
00032 #include "MyGUI_LayoutManager.h"
00033 #include "MyGUI_PluginManager.h"
00034 #include "MyGUI_SkinManager.h"
00035 #include "MyGUI_WidgetManager.h"
00036 #include "MyGUI_FactoryManager.h"
00037 #include "MyGUI_DeprecatedWidgets.h"
00038 
00039 namespace MyGUI
00040 {
00041 
00042 #ifndef MYGUI_DONT_USE_OBSOLETE
00043 
00044     void MemberObsolete<Button>::setButtonPressed(bool _value)
00045     {
00046         static_cast<Button*>(this)->setStateSelected(_value);
00047     }
00048     bool MemberObsolete<Button>::getButtonPressed()
00049     {
00050         return static_cast<Button*>(this)->getStateSelected();
00051     }
00052     void MemberObsolete<Button>::setStateCheck(bool _value)
00053     {
00054         static_cast<Button*>(this)->setStateSelected(_value);
00055     }
00056     bool MemberObsolete<Button>::getStateCheck()
00057     {
00058         return static_cast<Button*>(this)->getStateSelected();
00059     }
00060     ImageBox* MemberObsolete<Button>::getStaticImage()
00061     {
00062         return static_cast<Button*>(this)->_getImageBox();
00063     }
00064     void MemberObsolete<Button>::setImageIndex(size_t _index)
00065     {
00066         if (static_cast<Button*>(this)->_getImageBox())
00067             static_cast<Button*>(this)->_getImageBox()->setImageIndex(_index);
00068     }
00069     size_t MemberObsolete<Button>::getImageIndex()
00070     {
00071         if (static_cast<Button*>(this)->_getImageBox())
00072             return static_cast<Button*>(this)->_getImageBox()->getImageIndex();
00073         return ITEM_NONE;
00074     }
00075 
00076     void MemberObsolete<ImageBox>::addItemFrameDublicate(size_t _index, size_t _indexSourceFrame)
00077     {
00078         static_cast<ImageBox*>(this)->addItemFrameDuplicate(_index, _indexSourceFrame);
00079     }
00080     void MemberObsolete<ImageBox>::insertItemFrameDublicate(size_t _index, size_t _indexFrame, size_t _indexSourceFrame)
00081     {
00082         static_cast<ImageBox*>(this)->insertItemFrameDuplicate(_index, _indexFrame, _indexSourceFrame);
00083     }
00084 
00085 
00086     size_t MemberObsolete<ComboBox>::getItemIndexSelected()
00087     {
00088         return static_cast<ComboBox*>(this)->getIndexSelected();
00089     }
00090     void MemberObsolete<ComboBox>::setItemSelectedAt(size_t _index)
00091     {
00092         static_cast<ComboBox*>(this)->setIndexSelected(_index);
00093     }
00094     void MemberObsolete<ComboBox>::clearItemSelected()
00095     {
00096         static_cast<ComboBox*>(this)->clearIndexSelected();
00097     }
00098 
00099     void MemberObsolete<ComboBox>::insertItem(size_t _index, const UString& _name)
00100     {
00101         static_cast<ComboBox*>(this)->insertItemAt(_index, _name);
00102     }
00103     void MemberObsolete<ComboBox>::setItem(size_t _index, const UString& _item)
00104     {
00105         static_cast<ComboBox*>(this)->setItemNameAt(_index, _item);
00106     }
00107     const UString& MemberObsolete<ComboBox>::getItem(size_t _index)
00108     {
00109         return static_cast<ComboBox*>(this)->getItemNameAt(_index);
00110     }
00111     void MemberObsolete<ComboBox>::deleteItem(size_t _index)
00112     {
00113         static_cast<ComboBox*>(this)->removeItemAt(_index);
00114     }
00115     void MemberObsolete<ComboBox>::deleteAllItems()
00116     {
00117         static_cast<ComboBox*>(this)->removeAllItems();
00118     }
00119     size_t MemberObsolete<ComboBox>::getItemSelect()
00120     {
00121         return static_cast<ComboBox*>(this)->getIndexSelected();
00122     }
00123     void MemberObsolete<ComboBox>::resetItemSelect()
00124     {
00125         static_cast<ComboBox*>(this)->clearIndexSelected();
00126     }
00127     void MemberObsolete<ComboBox>::setItemSelect(size_t _index)
00128     {
00129         static_cast<ComboBox*>(this)->setIndexSelected(_index);
00130     }
00131 
00132     void MemberObsolete<ComboBox>::setMaxListHeight(int _value)
00133     {
00134         static_cast<ComboBox*>(this)->setMaxListLength(_value);
00135     }
00136     int MemberObsolete<ComboBox>::getMaxListHeight()
00137     {
00138         return static_cast<ComboBox*>(this)->getMaxListLength();
00139     }
00140 
00141 
00142     void MemberObsolete<EditBox>::showVScroll(bool _visible)
00143     {
00144         static_cast<EditBox*>(this)->setVisibleVScroll(_visible);
00145     }
00146     bool MemberObsolete<EditBox>::isShowVScroll()
00147     {
00148         return static_cast<EditBox*>(this)->isVisibleVScroll();
00149     }
00150     void MemberObsolete<EditBox>::showHScroll(bool _visible)
00151     {
00152         static_cast<EditBox*>(this)->setVisibleHScroll(_visible);
00153     }
00154     bool MemberObsolete<EditBox>::isShowHScroll()
00155     {
00156         return static_cast<EditBox*>(this)->isVisibleHScroll();
00157     }
00158 
00159     void MemberObsolete<EditBox>::setTextColour(size_t _start, size_t _count, const Colour& _colour)
00160     {
00161         static_cast<EditBox*>(this)->setTextIntervalColour(_start, _count, _colour);
00162     }
00163     void MemberObsolete<EditBox>::getTextSelect(size_t& _start, size_t& _end)
00164     {
00165         _start = static_cast<EditBox*>(this)->getTextSelectionStart();
00166         _end = static_cast<EditBox*>(this)->getTextSelectionEnd();
00167     }
00168     UString MemberObsolete<EditBox>::getText(size_t _start, size_t _count)
00169     {
00170         return static_cast<EditBox*>(this)->getTextInterval(_start, _count);
00171     }
00172     void MemberObsolete<EditBox>::setTextSelect(size_t _start, size_t _end)
00173     {
00174         static_cast<EditBox*>(this)->setTextSelection(_start, _end);
00175     }
00176     void MemberObsolete<EditBox>::deleteTextSelect()
00177     {
00178         static_cast<EditBox*>(this)->deleteTextSelection();
00179     }
00180     UString MemberObsolete<EditBox>::getSelectedText()
00181     {
00182         return static_cast<EditBox*>(this)->getTextSelection();
00183     }
00184     bool MemberObsolete<EditBox>::isTextSelect()
00185     {
00186         return static_cast<EditBox*>(this)->isTextSelection();
00187     }
00188     void MemberObsolete<EditBox>::setTextSelectColour(const Colour& _colour)
00189     {
00190         static_cast<EditBox*>(this)->setTextSelectionColour(_colour);
00191     }
00192 
00193 
00194     size_t MemberObsolete<ItemBox>::getItemIndexSelected()
00195     {
00196         return static_cast<ItemBox*>(this)->getIndexSelected();
00197     }
00198     void MemberObsolete<ItemBox>::setItemSelectedAt(size_t _index)
00199     {
00200         static_cast<ItemBox*>(this)->setIndexSelected(_index);
00201     }
00202     void MemberObsolete<ItemBox>::clearItemSelected()
00203     {
00204         static_cast<ItemBox*>(this)->clearIndexSelected();
00205     }
00206 
00207     void MemberObsolete<ItemBox>::insertItem(size_t _index, Any _data)
00208     {
00209         static_cast<ItemBox*>(this)->insertItemAt(_index, _data);
00210     }
00211     void MemberObsolete<ItemBox>::setItemData(size_t _index, Any _data)
00212     {
00213         static_cast<ItemBox*>(this)->setItemDataAt(_index, _data);
00214     }
00215     void MemberObsolete<ItemBox>::deleteItem(size_t _index)
00216     {
00217         static_cast<ItemBox*>(this)->removeItemAt(_index);
00218     }
00219     void MemberObsolete<ItemBox>::deleteAllItems()
00220     {
00221         static_cast<ItemBox*>(this)->removeAllItems();
00222     }
00223     size_t MemberObsolete<ItemBox>::getItemSelect()
00224     {
00225         return static_cast<ItemBox*>(this)->getIndexSelected();
00226     }
00227     void MemberObsolete<ItemBox>::resetItemSelect()
00228     {
00229         static_cast<ItemBox*>(this)->clearIndexSelected();
00230     }
00231     void MemberObsolete<ItemBox>::setItemSelect(size_t _index)
00232     {
00233         static_cast<ItemBox*>(this)->setIndexSelected(_index);
00234     }
00235 
00236     Widget* MemberObsolete<ItemBox>::getWidgetDrop()
00237     {
00238         return static_cast<ItemBox*>(this)->getWidgetDrag();
00239     }
00240     void MemberObsolete<ItemBox>::resetDrop()
00241     {
00242         static_cast<ItemBox*>(this)->resetDrag();
00243     }
00244 
00245     void MemberObsolete<ItemBox>::setItemBoxAlignVert(bool _value)
00246     {
00247         static_cast<ItemBox*>(this)->setVerticalAlignment(_value);
00248     }
00249     bool MemberObsolete<ItemBox>::getItemBoxAlignVert()
00250     {
00251         return static_cast<ItemBox*>(this)->getVerticalAlignment();
00252     }
00253 
00254 
00255     size_t MemberObsolete<ListBox>::getItemIndexSelected()
00256     {
00257         return static_cast<ListBox*>(this)->getIndexSelected();
00258     }
00259     void MemberObsolete<ListBox>::setItemSelectedAt(size_t _index)
00260     {
00261         static_cast<ListBox*>(this)->setIndexSelected(_index);
00262     }
00263     void MemberObsolete<ListBox>::clearItemSelected()
00264     {
00265         static_cast<ListBox*>(this)->clearIndexSelected();
00266     }
00267 
00268     void MemberObsolete<ListBox>::insertItem(size_t _index, const UString& _item)
00269     {
00270         static_cast<ListBox*>(this)->insertItemAt(_index, _item);
00271     }
00272     void MemberObsolete<ListBox>::setItem(size_t _index, const UString& _item)
00273     {
00274         static_cast<ListBox*>(this)->setItemNameAt(_index, _item);
00275     }
00276     const UString& MemberObsolete<ListBox>::getItem(size_t _index)
00277     {
00278         return static_cast<ListBox*>(this)->getItemNameAt(_index);
00279     }
00280     void MemberObsolete<ListBox>::deleteItem(size_t _index)
00281     {
00282         static_cast<ListBox*>(this)->removeItemAt(_index);
00283     }
00284     void MemberObsolete<ListBox>::deleteAllItems()
00285     {
00286         static_cast<ListBox*>(this)->removeAllItems();
00287     }
00288     size_t MemberObsolete<ListBox>::findItem(const UString& _item)
00289     {
00290         return static_cast<ListBox*>(this)->findItemIndexWith(_item);
00291     }
00292     size_t MemberObsolete<ListBox>::getItemSelect()
00293     {
00294         return static_cast<ListBox*>(this)->getIndexSelected();
00295     }
00296     void MemberObsolete<ListBox>::resetItemSelect()
00297     {
00298         static_cast<ListBox*>(this)->clearIndexSelected();
00299     }
00300     void MemberObsolete<ListBox>::setItemSelect(size_t _index)
00301     {
00302         static_cast<ListBox*>(this)->setIndexSelected(_index);
00303     }
00304     void MemberObsolete<ListBox>::beginToIndex(size_t _index)
00305     {
00306         static_cast<ListBox*>(this)->beginToItemAt(_index);
00307     }
00308     void MemberObsolete<ListBox>::beginToStart()
00309     {
00310         static_cast<ListBox*>(this)->beginToItemFirst();
00311     }
00312     void MemberObsolete<ListBox>::beginToEnd()
00313     {
00314         static_cast<ListBox*>(this)->beginToItemLast();
00315     }
00316     void MemberObsolete<ListBox>::beginToSelect()
00317     {
00318         static_cast<ListBox*>(this)->beginToItemSelected();
00319     }
00320     bool MemberObsolete<ListBox>::isItemVisible(size_t _index, bool _fill)
00321     {
00322         return static_cast<ListBox*>(this)->isItemVisibleAt(_index, _fill);
00323     }
00324     bool MemberObsolete<ListBox>::isItemSelectVisible(bool _fill)
00325     {
00326         return static_cast<ListBox*>(this)->isItemSelectedVisible(_fill);
00327     }
00328 
00329 
00330     void MemberObsolete<MenuControl>::showMenu()
00331     {
00332         static_cast<MenuControl*>(this)->setVisible(true);
00333     }
00334     void MemberObsolete<MenuControl>::hideMenu()
00335     {
00336         static_cast<MenuControl*>(this)->setVisible(false);
00337     }
00338     bool MemberObsolete<MenuControl>::isShowMenu()
00339     {
00340         return static_cast<MenuControl*>(this)->getVisible();
00341     }
00342 
00343     void MemberObsolete<MenuControl>::showItemChildAt(size_t _index)
00344     {
00345         static_cast<MenuControl*>(this)->setItemChildVisibleAt(_index, true);
00346     }
00347     void MemberObsolete<MenuControl>::showItemChild(MenuItem* _item)
00348     {
00349         static_cast<MenuControl*>(this)->setItemChildVisible(_item, true);
00350     }
00351     void MemberObsolete<MenuControl>::hideItemChildAt(size_t _index)
00352     {
00353         static_cast<MenuControl*>(this)->setItemChildVisibleAt(_index, false);
00354     }
00355     void MemberObsolete<MenuControl>::hideItemChild(MenuItem* _item)
00356     {
00357         static_cast<MenuControl*>(this)->setItemChildVisible(_item, false);
00358     }
00359 
00360     void MemberObsolete<MenuControl>::setAlignVert(bool _value)
00361     {
00362         static_cast<MenuControl*>(this)->setVerticalAlignment(_value);
00363     }
00364     bool MemberObsolete<MenuControl>::getAlignVert()
00365     {
00366         return static_cast<MenuControl*>(this)->getVerticalAlignment();
00367     }
00368 
00369     void MemberObsolete<MenuItem>::showItemChild()
00370     {
00371         static_cast<MenuItem*>(this)->setItemChildVisible(true);
00372     }
00373     void MemberObsolete<MenuItem>::hideItemChild()
00374     {
00375         static_cast<MenuItem*>(this)->setItemChildVisible(false);
00376     }
00377 
00378 
00379     size_t MemberObsolete<MultiListBox>::getItemIndexSelected()
00380     {
00381         return static_cast<MultiListBox*>(this)->getIndexSelected();
00382     }
00383     void MemberObsolete<MultiListBox>::setItemSelectedAt(size_t _index)
00384     {
00385         static_cast<MultiListBox*>(this)->setIndexSelected(_index);
00386     }
00387     void MemberObsolete<MultiListBox>::clearItemSelected()
00388     {
00389         static_cast<MultiListBox*>(this)->clearIndexSelected();
00390     }
00391 
00392     size_t MemberObsolete<MultiListBox>::findItem(size_t _column, const UString& _name)
00393     {
00394         return static_cast<MultiListBox*>(this)->findSubItemWith(_column, _name);
00395     }
00396     const UString& MemberObsolete<MultiListBox>::getSubItem(size_t _column, size_t _index)
00397     {
00398         return static_cast<MultiListBox*>(this)->getSubItemNameAt(_column, _index);
00399     }
00400     void MemberObsolete<MultiListBox>::setSubItem(size_t _column, size_t _index, const UString& _name)
00401     {
00402         static_cast<MultiListBox*>(this)->setSubItemNameAt(_column, _index, _name);
00403     }
00404     void MemberObsolete<MultiListBox>::deleteColumn(size_t _column)
00405     {
00406         static_cast<MultiListBox*>(this)->removeColumnAt(_column);
00407     }
00408     void MemberObsolete<MultiListBox>::deleteAllColumns()
00409     {
00410         static_cast<MultiListBox*>(this)->removeAllColumns();
00411     }
00412     int MemberObsolete<MultiListBox>::getColumnWidth(size_t _column)
00413     {
00414         return static_cast<MultiListBox*>(this)->getColumnWidthAt(_column);
00415     }
00416     const UString& MemberObsolete<MultiListBox>::getColumnName(size_t _column)
00417     {
00418         return static_cast<MultiListBox*>(this)->getColumnNameAt(_column);
00419     }
00420     void MemberObsolete<MultiListBox>::setColumnWidth(size_t _column, int _width)
00421     {
00422         static_cast<MultiListBox*>(this)->setColumnWidthAt(_column, _width);
00423     }
00424     void MemberObsolete<MultiListBox>::addColumn(int _width, const UString& _name)
00425     {
00426         static_cast<MultiListBox*>(this)->addColumn(_name, _width);
00427     }
00428     void MemberObsolete<MultiListBox>::setColumnName(size_t _column, const UString& _name)
00429     {
00430         static_cast<MultiListBox*>(this)->setColumnNameAt(_column, _name);
00431     }
00432     void MemberObsolete<MultiListBox>::insertColumn(size_t _column, int _width, const UString& _name)
00433     {
00434         static_cast<MultiListBox*>(this)->insertColumnAt(_column, _name, _width);
00435     }
00436     size_t MemberObsolete<MultiListBox>::getItemSelect()
00437     {
00438         return static_cast<MultiListBox*>(this)->getIndexSelected();
00439     }
00440     void MemberObsolete<MultiListBox>::resetItemSelect()
00441     {
00442         static_cast<MultiListBox*>(this)->clearIndexSelected();
00443     }
00444     void MemberObsolete<MultiListBox>::setItemSelect(size_t _index)
00445     {
00446         static_cast<MultiListBox*>(this)->setIndexSelected(_index);
00447     }
00448     void MemberObsolete<MultiListBox>::insertItem(size_t _index, const UString& _name)
00449     {
00450         static_cast<MultiListBox*>(this)->insertItemAt(_index, _name);
00451     }
00452     void MemberObsolete<MultiListBox>::setItem(size_t _index, const UString& _name)
00453     {
00454         static_cast<MultiListBox*>(this)->setItemNameAt(_index, _name);
00455     }
00456     const UString& MemberObsolete<MultiListBox>::getItem(size_t _index)
00457     {
00458         return static_cast<MultiListBox*>(this)->getItemNameAt(_index);
00459     }
00460     void MemberObsolete<MultiListBox>::deleteItem(size_t _index)
00461     {
00462         static_cast<MultiListBox*>(this)->removeItemAt(_index);
00463     }
00464     void MemberObsolete<MultiListBox>::deleteAllItems()
00465     {
00466         static_cast<MultiListBox*>(this)->removeAllItems();
00467     }
00468 
00469 
00470     void MemberObsolete<ProgressBar>::setProgressStartPoint(Align _value)
00471     {
00472         if (_value == Align::Right)
00473             static_cast<ProgressBar*>(this)->setFlowDirection(FlowDirection::RightToLeft);
00474         else if (_value == Align::Top)
00475             static_cast<ProgressBar*>(this)->setFlowDirection(FlowDirection::TopToBottom);
00476         else if (_value == Align::Bottom)
00477             static_cast<ProgressBar*>(this)->setFlowDirection(FlowDirection::BottomToTop);
00478         else
00479             static_cast<ProgressBar*>(this)->setFlowDirection(FlowDirection::LeftToRight);
00480     }
00481 
00482     Align MemberObsolete<ProgressBar>::getProgressStartPoint()
00483     {
00484         if (static_cast<ProgressBar*>(this)->getFlowDirection() == FlowDirection::RightToLeft)
00485             return Align::Right;
00486         else if (static_cast<ProgressBar*>(this)->getFlowDirection() == FlowDirection::TopToBottom)
00487             return Align::Top;
00488         else if (static_cast<ProgressBar*>(this)->getFlowDirection() == FlowDirection::BottomToTop)
00489             return Align::Bottom;
00490 
00491         return Align::Left;
00492     }
00493 
00494 
00495     void MemberObsolete<ScrollView>::showVScroll(bool _visible)
00496     {
00497         static_cast<ScrollView*>(this)->setVisibleVScroll(_visible);
00498     }
00499     bool MemberObsolete<ScrollView>::isShowVScroll()
00500     {
00501         return static_cast<ScrollView*>(this)->isVisibleVScroll();
00502     }
00503     void MemberObsolete<ScrollView>::showHScroll(bool _visible)
00504     {
00505         static_cast<ScrollView*>(this)->setVisibleHScroll(_visible);
00506     }
00507     bool MemberObsolete<ScrollView>::isShowHScroll()
00508     {
00509         return static_cast<ScrollView*>(this)->isVisibleHScroll();
00510     }
00511 
00512 
00513     int MemberObsolete<TabControl>::getSheetButtonWidthIndex(size_t _index)
00514     {
00515         return static_cast<TabControl*>(this)->getButtonWidthAt(_index);
00516     }
00517     int MemberObsolete<TabControl>::getSheetButtonWidth(TabItem* _sheet)
00518     {
00519         return static_cast<TabControl*>(this)->getButtonWidth(_sheet);
00520     }
00521     void MemberObsolete<TabControl>::setSheetButtonWidthIndex(size_t _index, int _width)
00522     {
00523         static_cast<TabControl*>(this)->setButtonWidthAt(_index, _width);
00524     }
00525     void MemberObsolete<TabControl>::setSheetButtonWidth(TabItem* _sheet, int _width)
00526     {
00527         static_cast<TabControl*>(this)->setButtonWidth(_sheet, _width);
00528     }
00529     void MemberObsolete<TabControl>::showBarButton(size_t _index)
00530     {
00531         static_cast<TabControl*>(this)->beginToItemAt(_index);
00532     }
00533     void MemberObsolete<TabControl>::showBarSelectButton()
00534     {
00535         static_cast<TabControl*>(this)->beginToItemSelected();
00536     }
00537     size_t MemberObsolete<TabControl>::getSheetCount()
00538     {
00539         return static_cast<TabControl*>(this)->getItemCount();
00540     }
00541     const UString& MemberObsolete<TabControl>::getSheetName(TabItem* _sheet)
00542     {
00543         return static_cast<TabControl*>(this)->getItemName(_sheet);
00544     }
00545     const UString& MemberObsolete<TabControl>::getSheetNameIndex(size_t _index)
00546     {
00547         return static_cast<TabControl*>(this)->getItemNameAt(_index);
00548     }
00549     TabItem* MemberObsolete<TabControl>::getSheet(size_t _index)
00550     {
00551         return static_cast<TabControl*>(this)->getItemAt(_index);
00552     }
00553     void MemberObsolete<TabControl>::setSheetNameIndex(size_t _index, const UString& _name, int _width)
00554     {
00555         static_cast<TabControl*>(this)->setItemNameAt(_index, _name);
00556     }
00557     void MemberObsolete<TabControl>::setSheetName(TabItem* _sheet, const UString& _name, int _width)
00558     {
00559         static_cast<TabControl*>(this)->setItemName(_sheet, _name);
00560     }
00561     TabItem* MemberObsolete<TabControl>::addSheet(const UString& _name, int _width)
00562     {
00563         return static_cast<TabControl*>(this)->addItem(_name, _width);
00564     }
00565     TabItem* MemberObsolete<TabControl>::insertSheet(size_t _index, const UString& _name, int _width)
00566     {
00567         return static_cast<TabControl*>(this)->insertItemAt(_index, _name);
00568     }
00569     void MemberObsolete<TabControl>::removeSheetIndex(size_t _index)
00570     {
00571         static_cast<TabControl*>(this)->removeItemAt(_index);
00572     }
00573     void MemberObsolete<TabControl>::removeSheet(TabItem* _sheet)
00574     {
00575         static_cast<TabControl*>(this)->removeItem(_sheet);
00576     }
00577     void MemberObsolete<TabControl>::selectSheetIndex(size_t _index, bool _smooth)
00578     {
00579         static_cast<TabControl*>(this)->setIndexSelected(_index);
00580     }
00581     void MemberObsolete<TabControl>::selectSheet(TabItem* _sheet, bool _smooth)
00582     {
00583         static_cast<TabControl*>(this)->setItemSelected(_sheet);
00584     }
00585     size_t MemberObsolete<TabControl>::getSelectSheetIndex()
00586     {
00587         return static_cast<TabControl*>(this)->getIndexSelected();
00588     }
00589 
00590     size_t MemberObsolete<TabControl>::getItemIndexSelected()
00591     {
00592         return static_cast<TabControl*>(this)->getIndexSelected();
00593     }
00594     void MemberObsolete<TabControl>::setItemSelectedAt(size_t _index)
00595     {
00596         static_cast<TabControl*>(this)->setIndexSelected(_index);
00597     }
00598 
00599 
00600     bool MemberObsolete<Widget>::isEnabled()
00601     {
00602         return static_cast<Widget*>(this)->getEnabled();
00603     }
00604     bool MemberObsolete<Widget>::isInheritsAlpha()
00605     {
00606         return static_cast<Widget*>(this)->getInheritsAlpha();
00607     }
00608     bool MemberObsolete<Widget>::isNeedKeyFocus()
00609     {
00610         return static_cast<Widget*>(this)->getNeedKeyFocus();
00611     }
00612     bool MemberObsolete<Widget>::isNeedMouseFocus()
00613     {
00614         return static_cast<Widget*>(this)->getNeedMouseFocus();
00615     }
00616     bool MemberObsolete<Widget>::isInheritsPick()
00617     {
00618         return static_cast<Widget*>(this)->getInheritsPick();
00619     }
00620     bool MemberObsolete<Widget>::isVisible()
00621     {
00622         return static_cast<Widget*>(this)->getVisible();
00623     }
00624 
00625 
00626     void MemberObsolete<Window>::showSmooth(bool _reset)
00627     {
00628         static_cast<Window*>(this)->setVisibleSmooth(true);
00629     }
00630     void MemberObsolete<Window>::hideSmooth()
00631     {
00632         static_cast<Window*>(this)->setVisibleSmooth(false);
00633     }
00634     void MemberObsolete<Window>::setMinMax(const IntRect& _minmax)
00635     {
00636         static_cast<Window*>(this)->setMinSize(_minmax.left, _minmax.top);
00637         static_cast<Window*>(this)->setMaxSize(_minmax.right, _minmax.bottom);
00638     }
00639     void MemberObsolete<Window>::setMinMax(int _min_w, int _min_h, int _max_w, int _max_h)
00640     {
00641         static_cast<Window*>(this)->setMinSize(_min_w, _min_h);
00642         static_cast<Window*>(this)->setMaxSize(_max_w, _max_h);
00643     }
00644     IntRect MemberObsolete<Window>::getMinMax()
00645     {
00646         return IntRect(static_cast<Window*>(this)->getMinSize().width, static_cast<Window*>(this)->getMinSize().height, static_cast<Window*>(this)->getMaxSize().width, static_cast<Window*>(this)->getMaxSize().height);
00647     }
00648 
00649     bool MemberObsolete<FontManager>::load(const std::string& _file)
00650     {
00651         return ResourceManager::getInstance().load(_file);
00652     }
00653 
00654     void MemberObsolete<FontManager>::loadOldFontFormat(xml::ElementPtr _node2, const std::string& _file, Version _version, const std::string& _tag)
00655     {
00656         xml::ElementEnumerator _node = _node2->getElementEnumerator();
00657         while (_node.next())
00658         {
00659             if (_node->getName() == _tag)
00660             {
00661                 std::string name;
00662                 if (!_node->findAttribute("name", name))
00663                     return;
00664 
00665                 std::string type;
00666                 if (type.empty())
00667                 {
00668                     if (_node->findAttribute("resolution").empty())
00669                         type = "ResourceManualFont";
00670                     else
00671                         type = "ResourceTrueTypeFont";
00672                 }
00673 
00674                 xml::Document doc;
00675                 xml::ElementPtr root = doc.createRoot("MyGUI");
00676                 xml::ElementPtr node = root->createChild("Resource");
00677                 node->addAttribute("type", type);
00678                 node->addAttribute("name", name);
00679 
00680                 std::string tmp;
00681                 if (_node->findAttribute("source", tmp))
00682                 {
00683                     xml::ElementPtr prop = node->createChild("Property");
00684                     prop->addAttribute("key", "Source");
00685                     prop->addAttribute("value", tmp);
00686                 }
00687 
00688                 if (_node->findAttribute("size", tmp))
00689                 {
00690                     xml::ElementPtr prop = node->createChild("Property");
00691                     prop->addAttribute("key", "Size");
00692                     prop->addAttribute("value", tmp);
00693                 }
00694 
00695                 if (_node->findAttribute("resolution", tmp))
00696                 {
00697                     xml::ElementPtr prop = node->createChild("Property");
00698                     prop->addAttribute("key", "Resolution");
00699                     prop->addAttribute("value", tmp);
00700                 }
00701 
00702                 if (_node->findAttribute("antialias_colour", tmp))
00703                 {
00704                     xml::ElementPtr prop = node->createChild("Property");
00705                     prop->addAttribute("key", "Antialias");
00706                     prop->addAttribute("value", tmp);
00707                 }
00708 
00709                 if (_node->findAttribute("space_width", tmp))
00710                 {
00711                     xml::ElementPtr prop = node->createChild("Property");
00712                     prop->addAttribute("key", "SpaceWidth");
00713                     prop->addAttribute("value", tmp);
00714                 }
00715 
00716                 if (_node->findAttribute("tab_width", tmp))
00717                 {
00718                     xml::ElementPtr prop = node->createChild("Property");
00719                     prop->addAttribute("key", "TabWidth");
00720                     prop->addAttribute("value", tmp);
00721                 }
00722 
00723                 if (_node->findAttribute("cursor_width", tmp))
00724                 {
00725                     xml::ElementPtr prop = node->createChild("Property");
00726                     prop->addAttribute("key", "CursorWidth");
00727                     prop->addAttribute("value", tmp);
00728                 }
00729 
00730                 if (_node->findAttribute("distance", tmp))
00731                 {
00732                     xml::ElementPtr prop = node->createChild("Property");
00733                     prop->addAttribute("key", "Distance");
00734                     prop->addAttribute("value", tmp);
00735                 }
00736 
00737                 if (_node->findAttribute("offset_height", tmp))
00738                 {
00739                     xml::ElementPtr prop = node->createChild("Property");
00740                     prop->addAttribute("key", "OffsetHeight");
00741                     prop->addAttribute("value", tmp);
00742                 }
00743 
00744                 if (_node->findAttribute("default_height", tmp))
00745                 {
00746                     xml::ElementPtr prop = node->createChild("Property");
00747                     prop->addAttribute("key", "DefaultHeight");
00748                     prop->addAttribute("value", tmp);
00749                 }
00750 
00751                 xml::ElementPtr codes = node->createChild("Codes");
00752 
00753                 xml::ElementEnumerator codeold = _node->getElementEnumerator();
00754                 while (codeold.next("Code"))
00755                 {
00756                     xml::ElementPtr codenew = codes->createChild("Code");
00757 
00758                     if (codeold->findAttribute("range", tmp))
00759                         codenew->addAttribute("range", tmp);
00760 
00761                     if (codeold->findAttribute("hide", tmp))
00762                         codenew->addAttribute("hide", tmp);
00763 
00764                     if (codeold->findAttribute("index", tmp))
00765                         codenew->addAttribute("index", tmp);
00766 
00767                     if (codeold->findAttribute("coord", tmp))
00768                         codenew->addAttribute("coord", tmp);
00769                 }
00770 
00771                 ResourceManager::getInstance().loadFromXmlNode(root, _file, _version);
00772             }
00773         }
00774     }
00775 
00776     void MemberObsolete<Gui>::destroyWidgetsVector(VectorWidgetPtr& _widgets)
00777     {
00778         static_cast<Gui*>(this)->destroyWidgets(_widgets);
00779     }
00780 
00781     bool MemberObsolete<Gui>::injectMouseMove( int _absx, int _absy, int _absz)
00782     {
00783         return InputManager::getInstance().injectMouseMove(_absx, _absy, _absz);
00784     }
00785     bool MemberObsolete<Gui>::injectMousePress( int _absx, int _absy, MouseButton _id )
00786     {
00787         return InputManager::getInstance().injectMousePress(_absx, _absy, _id);
00788     }
00789     bool MemberObsolete<Gui>::injectMouseRelease( int _absx, int _absy, MouseButton _id )
00790     {
00791         return InputManager::getInstance().injectMouseRelease(_absx, _absy, _id);
00792     }
00793     bool MemberObsolete<Gui>::injectKeyPress(KeyCode _key, Char _text)
00794     {
00795         return InputManager::getInstance().injectKeyPress(_key, _text);
00796     }
00797     bool MemberObsolete<Gui>::injectKeyRelease(KeyCode _key)
00798     {
00799         return InputManager::getInstance().injectKeyRelease(_key);
00800     }
00801 
00802     void MemberObsolete<Gui>::hidePointer()
00803     {
00804         PointerManager::getInstance().setVisible(false);
00805     }
00806     void MemberObsolete<Gui>::showPointer()
00807     {
00808         PointerManager::getInstance().setVisible(true);
00809     }
00810     bool MemberObsolete<Gui>::isShowPointer()
00811     {
00812         return PointerManager::getInstance().isVisible();
00813     }
00814 
00815     bool MemberObsolete<Gui>::load(const std::string& _file)
00816     {
00817         return ResourceManager::getInstance().load(_file);
00818     }
00819 
00820     const IntSize& MemberObsolete<Gui>::getViewSize()
00821     {
00822         return RenderManager::getInstance().getViewSize();
00823     }
00824     int MemberObsolete<Gui>::getViewWidth()
00825     {
00826         return RenderManager::getInstance().getViewSize().width;
00827     }
00828     int MemberObsolete<Gui>::getViewHeight()
00829     {
00830         return RenderManager::getInstance().getViewSize().height;
00831     }
00832 
00833     void MemberObsolete<Gui>::setVisiblePointer(bool _value)
00834     {
00835         PointerManager::getInstance().setVisible(_value);
00836     }
00837     bool MemberObsolete<Gui>::isVisiblePointer()
00838     {
00839         return PointerManager::getInstance().isVisible();
00840     }
00841 
00842     void MemberObsolete<Gui>::_injectFrameEntered(float _time)
00843     {
00844         Gui::getInstance().frameEvent(_time);
00845     }
00846 
00847     void MemberObsolete<Gui>::_resizeWindow(const IntSize& _size)
00848     {
00849         LayerManager::getInstance().resizeView(_size);
00850     }
00851 
00852     const IntPoint& MemberObsolete<InputManager>::getLastLeftPressed() const
00853     {
00854         return InputManager::getInstance().getLastPressedPosition(MouseButton::Left);
00855     }
00856 
00857     const IntPoint& MemberObsolete<InputManager>::getLastRightPressed() const
00858     {
00859         return InputManager::getInstance().getLastPressedPosition(MouseButton::Right);
00860     }
00861 
00862     bool MemberObsolete<LanguageManager>::load(const std::string& _file)
00863     {
00864         return ResourceManager::getInstance().load(_file);
00865     }
00866 
00867     bool MemberObsolete<LayerManager>::load(const std::string& _file)
00868     {
00869         return ResourceManager::getInstance().load(_file);
00870     }
00871 
00872     VectorWidgetPtr MemberObsolete<LayoutManager>::load(const std::string& _file)
00873     {
00874         return static_cast<LayoutManager*>(this)->loadLayout(_file);
00875     }
00876 
00877     bool MemberObsolete<PluginManager>::load(const std::string& _file)
00878     {
00879         return ResourceManager::getInstance().load(_file);
00880     }
00881 
00882     void MemberObsolete<PointerManager>::setDeafultPointer(const std::string& _value)
00883     {
00884         static_cast<PointerManager*>(this)->setDefaultPointer(_value);
00885     }
00886     void MemberObsolete<PointerManager>::show()
00887     {
00888         static_cast<PointerManager*>(this)->setVisible(true);
00889     }
00890     void MemberObsolete<PointerManager>::hide()
00891     {
00892         static_cast<PointerManager*>(this)->setVisible(false);
00893     }
00894     bool MemberObsolete<PointerManager>::isShow()
00895     {
00896         return static_cast<PointerManager*>(this)->isVisible();
00897     }
00898     bool MemberObsolete<PointerManager>::load(const std::string& _file)
00899     {
00900         return ResourceManager::getInstance().load(_file);
00901     }
00902     void MemberObsolete<PointerManager>::loadOldPointerFormat(xml::ElementPtr _node, const std::string& _file, Version _version, const std::string& _tag)
00903     {
00904         std::string pointer;
00905         std::string layer;
00906 
00907         xml::ElementEnumerator node = _node->getElementEnumerator();
00908         while (node.next())
00909         {
00910             if (node->getName() == _tag)
00911             {
00912                 layer = node->findAttribute("layer");
00913                 pointer = node->findAttribute("default");
00914 
00915                 // ñîõðàíÿåì
00916                 std::string shared_text = node->findAttribute("texture");
00917 
00918                 // áåðåì äåòåé è êðóòèìñÿ, îñíîâíîé öèêë
00919                 xml::ElementEnumerator info = node->getElementEnumerator();
00920                 while (info.next("Info"))
00921                 {
00922                     std::string name = info->findAttribute("name");
00923                     if (name.empty())
00924                         continue;
00925 
00926                     std::string texture = info->findAttribute("texture");
00927 
00928                     std::string type = (shared_text.empty() && texture.empty()) ? "ResourceImageSetPointer" : "ResourceManualPointer";
00929 
00930                     xml::Document doc;
00931                     xml::ElementPtr root = doc.createRoot("MyGUI");
00932                     xml::ElementPtr newnode = root->createChild("Resource");
00933                     newnode->addAttribute("type", type);
00934                     newnode->addAttribute("name", name);
00935 
00936                     std::string tmp;
00937                     if (info->findAttribute("point", tmp))
00938                     {
00939                         xml::ElementPtr prop = newnode->createChild("Property");
00940                         prop->addAttribute("key", "Point");
00941                         prop->addAttribute("value", tmp);
00942                     }
00943 
00944                     if (info->findAttribute("size", tmp))
00945                     {
00946                         xml::ElementPtr prop = newnode->createChild("Property");
00947                         prop->addAttribute("key", "Size");
00948                         prop->addAttribute("value", tmp);
00949                     }
00950 
00951                     if (info->findAttribute("resource", tmp))
00952                     {
00953                         xml::ElementPtr prop = newnode->createChild("Property");
00954                         prop->addAttribute("key", "Resource");
00955                         prop->addAttribute("value", tmp);
00956                     }
00957 
00958                     if (info->findAttribute("offset", tmp))
00959                     {
00960                         xml::ElementPtr prop = newnode->createChild("Property");
00961                         prop->addAttribute("key", "Coord");
00962                         prop->addAttribute("value", tmp);
00963                     }
00964 
00965                     if (!shared_text.empty() || !texture.empty())
00966                     {
00967                         xml::ElementPtr prop = newnode->createChild("Property");
00968                         prop->addAttribute("key", "Texture");
00969                         prop->addAttribute("value",  shared_text.empty() ? texture : shared_text);
00970                     }
00971 
00972                     ResourceManager::getInstance().loadFromXmlNode(root, _file, _version);
00973                 }
00974             }
00975         }
00976 
00977         if (!layer.empty())
00978             static_cast<PointerManager*>(this)->setLayerName(layer);
00979 
00980         if (!pointer.empty())
00981             static_cast<PointerManager*>(this)->setDefaultPointer(pointer);
00982     }
00983 
00984     size_t MemberObsolete<ResourceManager>::getResourceCount()
00985     {
00986         return static_cast<ResourceManager*>(this)->getCount();
00987     }
00988     IResourcePtr MemberObsolete<ResourceManager>::getResource(const std::string& _name, bool _throw)
00989     {
00990         return static_cast<ResourceManager*>(this)->getByName(_name, _throw);
00991     }
00992 
00993     ResourceSkin* MemberObsolete<SkinManager>::getSkin(const std::string& _name)
00994     {
00995         return static_cast<SkinManager*>(this)->getByName(_name);
00996     }
00997     bool MemberObsolete<SkinManager>::load(const std::string& _file)
00998     {
00999         return ResourceManager::getInstance().load(_file);
01000     }
01001     void MemberObsolete<SkinManager>::loadOldSkinFormat(xml::ElementPtr _node, const std::string& _file, Version _version, const std::string& _tag)
01002     {
01003         std::string resourceCategory = ResourceManager::getInstance().getCategoryName();
01004 
01005         // áåðåì äåòåé è êðóòèìñÿ, îñíîâíîé öèêë ñî ñêèíàìè
01006         xml::ElementEnumerator skin = _node->getElementEnumerator();
01007         while (skin.next(_tag))
01008         {
01009             std::string type = skin->findAttribute("type");
01010             if (type.empty())
01011                 type = "ResourceSkin";
01012 
01013             IObject* object = FactoryManager::getInstance().createObject(resourceCategory, type);
01014             if (object != nullptr)
01015             {
01016                 ResourceSkin* data = object->castType<ResourceSkin>();
01017                 data->deserialization(skin.current(), _version);
01018 
01019                 ResourceManager::getInstance().addResource(data);
01020             }
01021         }
01022     }
01023 
01024 
01025     void MemberObsolete<WidgetManager>::destroyWidgetsVector(VectorWidgetPtr& _widgets)
01026     {
01027         static_cast<WidgetManager*>(this)->destroyWidgets(_widgets);
01028     }
01029     Widget* MemberObsolete<WidgetManager>::findWidgetT(const std::string& _name, bool _throw)
01030     {
01031         return Gui::getInstance().findWidgetT(_name, _throw);
01032     }
01033     Widget* MemberObsolete<WidgetManager>::findWidgetT(const std::string& _name, const std::string& _prefix, bool _throw)
01034     {
01035         return Gui::getInstance().findWidgetT(_name, _prefix, _throw);
01036     }
01037     void MemberObsolete<WidgetManager>::parse(Widget* _widget, const std::string& _key, const std::string& _value)
01038     {
01039         _widget->setProperty(_key, _value);
01040     }
01041 
01042 
01043 #endif // MYGUI_DONT_USE_OBSOLETE
01044 
01045 #ifndef MYGUI_DONT_USE_OBSOLETE
01046 
01047     static std::string convertAlignToDirection(const std::string& _value)
01048     {
01049         Align align = utility::parseValue<Align>(_value);
01050         if (align == Align::Right)
01051             return FlowDirection(FlowDirection::RightToLeft).print();
01052         else if (align == Align::Top)
01053             return FlowDirection(FlowDirection::TopToBottom).print();
01054         else if (align == Align::Bottom)
01055             return FlowDirection(FlowDirection::BottomToTop).print();
01056         return FlowDirection(FlowDirection::LeftToRight).print();
01057     }
01058 
01059     static std::string convertRectToCoord(const std::string& _value)
01060     {
01061         IntRect rect = IntRect::parse(_value);
01062         IntCoord coord(rect.left, rect.top, rect.width(), rect.height());
01063         return coord.print();
01064     }
01065 
01066     typedef std::set<std::string> SetString;
01067     static MapString mPropertyRename;
01068     static SetString mPropertyIgnore;
01069     static MapString mSkinRename;
01070 
01071 #endif // MYGUI_DONT_USE_OBSOLETE
01072 
01073     bool BackwardCompatibility::isIgnoreProperty(const std::string& _key)
01074     {
01075 #ifndef MYGUI_DONT_USE_OBSOLETE
01076         if (mPropertyIgnore.find(_key) != mPropertyIgnore.end())
01077             return true;
01078 #endif // MYGUI_DONT_USE_OBSOLETE
01079         return false;
01080     }
01081 
01082     bool BackwardCompatibility::checkProperty(Widget* _owner, std::string& _key, std::string& _value)
01083     {
01084 #ifndef MYGUI_DONT_USE_OBSOLETE
01085         if (mPropertyIgnore.find(_key) != mPropertyIgnore.end())
01086             return false;
01087 
01088         MapString::iterator item = mPropertyRename.find(_key);
01089         if (item != mPropertyRename.end())
01090         {
01091             MYGUI_LOG(Warning, (*item).first << " is deprecated, use " << (*item).second << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01092             _key = (*item).second;
01093         }
01094         else if (_key == "Progress_StartPoint")
01095         {
01096             MYGUI_LOG(Warning, "Progress_StartPoint is deprecated, use Progress_FlowDirection" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01097             _key = "Progress_FlowDirection";
01098             _value = convertAlignToDirection(_value);
01099         }
01100         else if (_key == "ComboBox_AddItem")
01101         {
01102             MYGUI_LOG(Warning, "ComboBox_AddItem is deprecated" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01103             ComboBox* widget = _owner->castType<ComboBox>(false);
01104             if (widget != nullptr)
01105                 widget->addItem(_value);
01106             return false;
01107         }
01108         else if (_key == "List_AddItem")
01109         {
01110             MYGUI_LOG(Warning, "List_AddItem is deprecated" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01111             ListBox* widget = _owner->castType<ListBox>(false);
01112             if (widget != nullptr)
01113                 widget->addItem(_value);
01114             return false;
01115         }
01116         else if (_key == "Tab_AddSheet")
01117         {
01118             MYGUI_LOG(Warning, "Tab_AddSheet is deprecated" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01119             TabControl* widget = _owner->castType<TabControl>(false);
01120             if (widget != nullptr)
01121                 widget->addItem(_value);
01122             return false;
01123         }
01124         else if (_key == "Tab_AddItem")
01125         {
01126             MYGUI_LOG(Warning, "Tab_AddItem is deprecated" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01127             TabControl* widget = _owner->castType<TabControl>(false);
01128             if (widget != nullptr)
01129                 widget->addItem(_value);
01130             return false;
01131         }
01132         else if (_key == "Window_MinMax")
01133         {
01134             MYGUI_LOG(Warning, "Window_MinMax is deprecated, use Window_MinSize or Window_MaxSize" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01135             Window* widget = _owner->castType<Window>(false);
01136             if (widget != nullptr)
01137             {
01138                 IntRect rect = IntRect::parse(_value);
01139                 widget->setMinSize(rect.left, rect.top);
01140                 widget->setMaxSize(rect.right, rect.bottom);
01141             }
01142             return false;
01143         }
01144         else if (_key == "ImageRect")
01145         {
01146             MYGUI_LOG(Warning, "ImageRect is deprecated, use ImageCoord" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01147             _key = "ImageCoord";
01148             _value = convertRectToCoord(_value);
01149         }
01150         else if (_key == "StartPoint")
01151         {
01152             MYGUI_LOG(Warning, "StartPoint is deprecated, use FlowDirection" << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01153             _key = "FlowDirection";
01154             _value = convertAlignToDirection(_value);
01155         }
01156 
01157 #endif // MYGUI_DONT_USE_OBSOLETE
01158         return true;
01159     }
01160 
01161     void BackwardCompatibility::initialise()
01162     {
01163 #ifndef MYGUI_DONT_USE_OBSOLETE
01164         mPropertyRename["Widget_Caption"] = "Caption";
01165         mPropertyRename["Button_Pressed"] = "StateSelected";
01166         mPropertyRename["ButtonPressed"] = "StateSelected";
01167         mPropertyRename["StateCheck"] = "StateSelected";
01168         mPropertyRename["Edit_ShowVScroll"] = "VisibleVScroll";
01169         mPropertyRename["Edit_ShowHScroll"] = "VisibleHScroll";
01170         mPropertyRename["ScrollView_VScroll"] = "VisibleVScroll";
01171         mPropertyRename["ScrollView_HScroll"] = "VisibleHScroll";
01172         mPropertyRename["Progress_Position"] = "RangePosition";
01173         mPropertyRename["Scroll_Position"] = "RangePosition";
01174         mPropertyRename["Tab_SelectSheet"] = "SelectItem";
01175         mPropertyRename["Image_Texture"] = "ImageTexture";
01176         mPropertyRename["Image_Coord"] = "ImageRegion";
01177         mPropertyRename["Image_Tile"] = "ImageTile";
01178         mPropertyRename["Image_Index"] = "ImageIndex";
01179         mPropertyRename["Image_Resource"] = "ImageResource";
01180         mPropertyRename["Image_Group"] = "ImageGroup";
01181         mPropertyRename["Image_Name"] = "ImageName";
01182         mPropertyRename["MenuItem_Id"] = "MenuItemId";
01183         mPropertyRename["MenuItem_Type"] = "MenuItemType";
01184         mPropertyRename["Combo_MaxLength"] = "MaxListLength";
01185         mPropertyRename["AlignText"] = "TextAlign";
01186         mPropertyRename["ToStick"] = "Snap";
01187         mPropertyRename["ListSmoothShow"] = "SmoothShow";
01188         mPropertyRename["HeightList"] = "MaxListLength";
01189         mPropertyRename["AlignVert"] = "VerticalAlignment";
01190 
01191         mPropertyIgnore.insert("DragLayer");
01192         mPropertyIgnore.insert("SkinLine");
01193         mPropertyIgnore.insert("HeightLine");
01194         mPropertyIgnore.insert("SkinLine");
01195         mPropertyIgnore.insert("HeightLine");
01196         mPropertyIgnore.insert("SeparatorHeight");
01197         mPropertyIgnore.insert("SeparatorSkin");
01198         mPropertyIgnore.insert("SubmenuImageSize");
01199         mPropertyIgnore.insert("SubMenuSkin");
01200         mPropertyIgnore.insert("SubMenuLayer");
01201         mPropertyIgnore.insert("DistanceButton");
01202         mPropertyIgnore.insert("ButtonSkin");
01203         mPropertyIgnore.insert("ButtonType");
01204         mPropertyIgnore.insert("ButtonSize");
01205         mPropertyIgnore.insert("ButtonOffset");
01206         mPropertyIgnore.insert("DefaultLayer");
01207         mPropertyIgnore.insert("FadeSkin");
01208         mPropertyIgnore.insert("FadeLayer");
01209         mPropertyIgnore.insert("SkinButton");
01210         mPropertyIgnore.insert("HeightButton");
01211         mPropertyIgnore.insert("SkinList");
01212         mPropertyIgnore.insert("SkinButtonEmpty");
01213         mPropertyIgnore.insert("WidthSeparator");
01214         mPropertyIgnore.insert("SkinSeparator");
01215         mPropertyIgnore.insert("TrackSkin");
01216         mPropertyIgnore.insert("TrackWidth");
01217         mPropertyIgnore.insert("TrackMin");
01218         mPropertyIgnore.insert("TrackStep");
01219         mPropertyIgnore.insert("TrackFill");
01220         mPropertyIgnore.insert("OffsetBar");
01221         mPropertyIgnore.insert("ButtonSkin");
01222         mPropertyIgnore.insert("EmptyBarSkin");
01223         mPropertyIgnore.insert("TrackRangeMargins");
01224         mPropertyIgnore.insert("MinTrackSize");
01225         mPropertyIgnore.insert("MainMove");
01226         mPropertyIgnore.insert("LevelOffset");
01227         mPropertyIgnore.insert("State");
01228 
01229         mSkinRename["StaticImage"] = "ImageBox";
01230         mSkinRename["StaticText"] = "TextBox";
01231         mSkinRename["HScroll"] = "ScrollBarH";
01232         mSkinRename["VScroll"] = "ScrollBarV";
01233         mSkinRename["ItemBoxH"] = "ItemBox";
01234         mSkinRename["ItemBoxV"] = "ItemBox";
01235         mSkinRename["VSlider"] = "SliderV";
01236         mSkinRename["HSlider"] = "SliderH";
01237         mSkinRename["Progress"] = "ProgressBar";
01238         mSkinRename["ProgressFill"] = "ProgressBarFill";
01239         mSkinRename["List"] = "ListBox";
01240         mSkinRename["MultiList"] = "MultiListBox";
01241         mSkinRename["Edit"] = "EditBox";
01242         mSkinRename["EditStretch"] = "EditBoxStretch";
01243         mSkinRename["EditEmpty"] = "EditBoxEmpty";
01244         mSkinRename["RadioBox"] = "RadioButton";
01245         mSkinRename["Tab"] = "TabControl";
01246         mSkinRename["WordWrap"] = "WordWrapEmpty";
01247         mSkinRename["WordWrapSimple"] = "WordWrapEmpty";
01248         mSkinRename["ButtonSmall"] = "Button";
01249         mSkinRename["ButtonImageText"] = "ButtonImage";
01250 
01251         mSkinRename["TileClient"] = "ClientTileSkin";
01252         mSkinRename["DefaultClient"] = "ClientDefaultSkin";
01253         mSkinRename["Panel"] = "PanelSkin";
01254         mSkinRename["PanelSmall"] = "PanelSkin";
01255         mSkinRename["Separator1"] = "SepUpVSkin";
01256         mSkinRename["Separator2"] = "SepDownVSkin";
01257         mSkinRename["Separator3"] = "SepUpHSkin";
01258         mSkinRename["Separator4"] = "SepDownHSkin";
01259         mSkinRename["MarkerWhite"] = "WhiteSkin";
01260         mSkinRename["ButtonLeft"] = "ButtonLeftSkin";
01261         mSkinRename["ButtonRight"] = "ButtonRightSkin";
01262         mSkinRename["ButtonUp"] = "ButtonUpSkin";
01263         mSkinRename["ButtonDown"] = "ButtonDownSkin";
01264         mSkinRename["ButtonV"] = "ButtonAcceptSkin";
01265         mSkinRename["ButtonX"] = "ButtonCloseSkin";
01266         mSkinRename["ButtonMinusPlus"] = "ButtonExpandSkin";
01267 #endif // MYGUI_DONT_USE_OBSOLETE
01268     }
01269 
01270     std::string BackwardCompatibility::getPropertyRename(const std::string& _propertyName)
01271     {
01272 #ifndef MYGUI_DONT_USE_OBSOLETE
01273         MapString::const_iterator item = mPropertyRename.find(_propertyName);
01274         if (item != mPropertyRename.end())
01275             return (*item).second;
01276 #endif // MYGUI_DONT_USE_OBSOLETE
01277         return _propertyName;
01278     }
01279 
01280     std::string BackwardCompatibility::getFactoryRename(const std::string& _categoryName, const std::string& _factoryName)
01281     {
01282 #ifndef MYGUI_DONT_USE_OBSOLETE
01283         if (_categoryName == "Widget")
01284         {
01285             if (_factoryName == "HScroll")
01286             {
01287                 MYGUI_LOG(Warning, "HScroll factory is deprecated, use " << ScrollBar::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01288             }
01289             else if (_factoryName == "VScroll")
01290             {
01291                 MYGUI_LOG(Warning, "VScroll factory is deprecated, use " << ScrollBar::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01292             }
01293             else if (_factoryName == "RenderBox")
01294             {
01295                 MYGUI_LOG(Warning, "RenderBox factory is deprecated, use " << Canvas::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01296             }
01297             else if (_factoryName == "Sheet")
01298             {
01299                 MYGUI_LOG(Warning, "Sheet factory is deprecated, use " << TabItem::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01300             }
01301             else if (_factoryName == "StaticImage")
01302             {
01303                 MYGUI_LOG(Warning, "StaticImage factory is deprecated, use " << ImageBox::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01304             }
01305             else if (_factoryName == "StaticText")
01306             {
01307                 MYGUI_LOG(Warning, "StaticText factory is deprecated, use " << TextBox::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01308             }
01309             else if (_factoryName == "Progress")
01310             {
01311                 MYGUI_LOG(Warning, "Progress factory is deprecated, use " << ProgressBar::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01312             }
01313             else if (_factoryName == "List")
01314             {
01315                 MYGUI_LOG(Warning, "List factory is deprecated, use " << ListBox::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01316             }
01317             else if (_factoryName == "Edit")
01318             {
01319                 MYGUI_LOG(Warning, "Edit factory is deprecated, use " << EditBox::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01320             }
01321             else if (_factoryName == "Tab")
01322             {
01323                 MYGUI_LOG(Warning, "Tab factory is deprecated, use " << TabControl::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01324             }
01325             else if (_factoryName == "MultiList")
01326             {
01327                 MYGUI_LOG(Warning, "MultiList factory is deprecated, use " << MultiListBox::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01328             }
01329             else if (_factoryName == "MenuCtrl")
01330             {
01331                 MYGUI_LOG(Warning, "MenuCtrl factory is deprecated, use " << MenuControl::getClassTypeName() << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01332             }
01333         }
01334 #endif // MYGUI_DONT_USE_OBSOLETE
01335         return _factoryName;
01336     }
01337 
01338     std::string BackwardCompatibility::getSkinRename(const std::string& _skinName)
01339     {
01340 #ifndef MYGUI_DONT_USE_OBSOLETE
01341         MapString::iterator item = mSkinRename.find(_skinName);
01342         if (item != mSkinRename.end())
01343         {
01344             MYGUI_LOG(Warning, (*item).first << " skin is deprecated, use " << (*item).second << " [" << LayoutManager::getInstance().getCurrentLayout() << "]");
01345             return (*item).second;
01346         }
01347 #endif // MYGUI_DONT_USE_OBSOLETE
01348         return _skinName;
01349     }
01350 
01351     void BackwardCompatibility::shutdown()
01352     {
01353 #ifndef MYGUI_DONT_USE_OBSOLETE
01354         mPropertyRename.clear();
01355 #endif // MYGUI_DONT_USE_OBSOLETE
01356     }
01357 
01358     void BackwardCompatibility::registerWidgetTypes()
01359     {
01360 #ifndef MYGUI_DONT_USE_OBSOLETE
01361         FactoryManager& factory = FactoryManager::getInstance();
01362         std::string widgetCategory = MyGUI::WidgetManager::getInstance().getCategoryName();
01363         factory.registerFactory<HScroll>(widgetCategory);
01364         factory.registerFactory<VScroll>(widgetCategory);
01365         factory.registerFactory<Canvas>(widgetCategory, "RenderBox");
01366         factory.registerFactory<TabItem>(widgetCategory, "Sheet");
01367         factory.registerFactory<ImageBox>(widgetCategory, "StaticImage");
01368         factory.registerFactory<TextBox>(widgetCategory, "StaticText");
01369         factory.registerFactory<ProgressBar>(widgetCategory, "Progress");
01370         factory.registerFactory<ListBox>(widgetCategory, "List");
01371         factory.registerFactory<EditBox>(widgetCategory, "Edit");
01372         factory.registerFactory<TabControl>(widgetCategory, "Tab");
01373         factory.registerFactory<MultiListBox>(widgetCategory, "MultiList");
01374         factory.registerFactory<MenuControl>(widgetCategory, "MenuCtrl");
01375 #endif // MYGUI_DONT_USE_OBSOLETE
01376     }
01377 
01378 } // namespace MyGUI