• Main Page
  • Related Pages
  • Namespaces
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

MyGUI_PointerManager.cpp

Go to the documentation of this file.
00001 
00007 /*
00008     This file is part of MyGUI.
00009     
00010     MyGUI is free software: you can redistribute it and/or modify
00011     it under the terms of the GNU Lesser General Public License as published by
00012     the Free Software Foundation, either version 3 of the License, or
00013     (at your option) any later version.
00014     
00015     MyGUI is distributed in the hope that it will be useful,
00016     but WITHOUT ANY WARRANTY; without even the implied warranty of
00017     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018     GNU Lesser General Public License for more details.
00019     
00020     You should have received a copy of the GNU Lesser General Public License
00021     along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
00022 */
00023 #include "MyGUI_Precompiled.h"
00024 #include "MyGUI_ResourceManager.h"
00025 #include "MyGUI_LayerManager.h"
00026 #include "MyGUI_PointerManager.h"
00027 #include "MyGUI_CoordConverter.h"
00028 #include "MyGUI_WidgetManager.h"
00029 #include "MyGUI_XmlDocument.h"
00030 #include "MyGUI_Widget.h"
00031 #include "MyGUI_FactoryManager.h"
00032 #include "MyGUI_InputManager.h"
00033 #include "MyGUI_Gui.h"
00034 
00035 #include "MyGUI_ResourceManualPointer.h"
00036 #include "MyGUI_ResourceImageSetPointer.h"
00037 
00038 namespace MyGUI
00039 {
00040 
00041     const std::string XML_TYPE("Pointer");
00042     const std::string XML_TYPE_RESOURCE("Resource");
00043     const std::string XML_TYPE_PROPERTY("Property");
00044     const std::string RESOURCE_DEFAULT_NAME("Default");
00045 
00046     MYGUI_INSTANCE_IMPLEMENT(PointerManager);
00047 
00048     void PointerManager::initialise()
00049     {
00050         MYGUI_ASSERT(false == mIsInitialise, INSTANCE_TYPE_NAME << " initialised twice");
00051         MYGUI_LOG(Info, "* Initialise: " << INSTANCE_TYPE_NAME);
00052 
00053         Gui::getInstance().eventFrameStart += newDelegate(this, &PointerManager::notifyFrameStart);
00054         InputManager::getInstance().eventChangeMouseFocus += newDelegate(this, &PointerManager::notifyChangeMouseFocus);
00055         WidgetManager::getInstance().registerUnlinker(this);
00056 
00057         ResourceManager::getInstance().registerLoadXmlDelegate(XML_TYPE) = newDelegate(this, &PointerManager::_load);
00058 
00059         FactoryManager::getInstance().registryFactory<ResourceManualPointer>(XML_TYPE_RESOURCE);
00060         FactoryManager::getInstance().registryFactory<ResourceImageSetPointer>(XML_TYPE_RESOURCE);
00061 
00062         mPointer = nullptr;
00063         mMousePointer = nullptr;
00064         mWidgetOwner = nullptr;
00065         mVisible = true;
00066 
00067         //mDefaultName = "arrow";
00068         //mLayerName = "Pointer";
00069 
00070         MYGUI_LOG(Info, INSTANCE_TYPE_NAME << " successfully initialized");
00071         mIsInitialise = true;
00072     }
00073 
00074     void PointerManager::shutdown()
00075     {
00076         if (false == mIsInitialise) return;
00077         MYGUI_LOG(Info, "* Shutdown: " << INSTANCE_TYPE_NAME);
00078 
00079         InputManager::getInstance().eventChangeMouseFocus -= newDelegate(this, &PointerManager::notifyChangeMouseFocus);
00080         Gui::getInstance().eventFrameStart -= newDelegate(this, &PointerManager::notifyFrameStart);
00081 
00082         FactoryManager::getInstance().unregistryFactory<ResourceManualPointer>(XML_TYPE_RESOURCE);
00083         FactoryManager::getInstance().unregistryFactory<ResourceImageSetPointer>(XML_TYPE_RESOURCE);
00084 
00085         // удаляем все виджеты
00086         _destroyAllChildWidget();
00087 
00088         mWidgetOwner = nullptr;
00089 
00090         WidgetManager::getInstance().unregisterUnlinker(this);
00091         ResourceManager::getInstance().unregisterLoadXmlDelegate(XML_TYPE);
00092 
00093         MYGUI_LOG(Info, INSTANCE_TYPE_NAME << " successfully shutdown");
00094         mIsInitialise = false;
00095     }
00096 
00097     bool PointerManager::load(const std::string& _file)
00098     {
00099         return ResourceManager::getInstance()._loadImplement(_file, true, XML_TYPE, INSTANCE_TYPE_NAME);
00100     }
00101 
00102     void PointerManager::_load(xml::ElementPtr _node, const std::string& _file, Version _version)
00103     {
00104         //std::string pointer;
00105         //std::string layer;
00106         //bool update = false;
00107 
00108         xml::ElementEnumerator node = _node->getElementEnumerator();
00109         while (node.next())
00110         {
00111             /*if (node->getName() == XML_TYPE)
00112             {
00113                 update = true;
00114 
00115                 layer = node->findAttribute("layer");
00116                 pointer = node->findAttribute("default");
00117 
00118                 // сохраняем
00119                 std::string shared_text = node->findAttribute("texture");
00120 
00121                 // берем детей и крутимся, основной цикл
00122                 xml::ElementEnumerator info = node->getElementEnumerator();
00123                 while (info.next("Info"))
00124                 {
00125                     std::string name = info->findAttribute("name");
00126                     if (name.empty()) continue;
00127 
00128                     std::string texture = info->findAttribute("texture");
00129 
00130                     std::string type = (shared_text.empty() && texture.empty()) ? "ResourceImageSetPointer" : "ResourceManualPointer";
00131 
00132                     xml::Document doc;
00133                     xml::ElementPtr root = doc.createRoot("MyGUI");
00134                     xml::ElementPtr newnode = root->createChild("Resource");
00135                     newnode->addAttribute("type", type);
00136                     newnode->addAttribute("name", name);
00137 
00138                     std::string tmp;
00139                     if (info->findAttribute("point", tmp))
00140                     {
00141                         xml::ElementPtr prop = newnode->createChild("Property");
00142                         prop->addAttribute("key", "Point");
00143                         prop->addAttribute("value", tmp);
00144                     }
00145                 
00146                     if (info->findAttribute("size", tmp))
00147                     {
00148                         xml::ElementPtr prop = newnode->createChild("Property");
00149                         prop->addAttribute("key", "Size");
00150                         prop->addAttribute("value", tmp);
00151                     }
00152                 
00153                     if (info->findAttribute("resource", tmp))
00154                     {
00155                         xml::ElementPtr prop = newnode->createChild("Property");
00156                         prop->addAttribute("key", "Resource");
00157                         prop->addAttribute("value", tmp);
00158                     }
00159                 
00160                     if (info->findAttribute("offset", tmp))
00161                     {
00162                         xml::ElementPtr prop = newnode->createChild("Property");
00163                         prop->addAttribute("key", "Coord");
00164                         prop->addAttribute("value", tmp);
00165                     }
00166                 
00167                     if (!shared_text.empty() || !texture.empty())
00168                     {
00169                         xml::ElementPtr prop = newnode->createChild("Property");
00170                         prop->addAttribute("key", "Texture");
00171                         prop->addAttribute("value",  shared_text.empty() ? texture : shared_text);
00172                     }
00173                 
00174                     ResourceManager::getInstance()._load(root, _file, _version);
00175                 }
00176 
00177             }
00178             else */if (node->getName() == XML_TYPE_PROPERTY)
00179             {
00180                 const std::string& key = node->findAttribute("key");
00181                 const std::string& value = node->findAttribute("value");
00182                 if (key == "Default")
00183                     setDeafultPointer(value);
00184                 else if (key == "Layer")
00185                     setLayerName(value);
00186             }
00187         }
00188 
00189         //FIXME
00190         /*if (update)
00191             Update();
00192 
00193         if (!pointer.empty())
00194             setDeafultPointer(pointer);
00195 
00196         if (!layer.empty())
00197             setLayerName(layer);*/
00198 
00199     }
00200 
00201     void PointerManager::notifyFrameStart(float _time)
00202     {
00203         mPoint = InputManager::getInstance().getMousePosition();
00204         if (nullptr != mMousePointer && mPointer != nullptr)
00205             mPointer->setPosition(mMousePointer, mPoint);
00206     }
00207 
00208     void PointerManager::setVisible(bool _visible)
00209     {
00210         if (nullptr != mMousePointer) mMousePointer->setVisible(_visible);
00211         mVisible = _visible;
00212     }
00213 
00214     void PointerManager::setPointer(const std::string& _name, WidgetPtr _owner)
00215     {
00216         //eventChangeMousePointer(_name);
00217 
00218         if (nullptr == mMousePointer)
00219             return;
00220 
00221         IResource* result = getByName(_name);
00222         if (result == nullptr)
00223         {
00224             mPointer = nullptr;
00225             mMousePointer->setVisible(false);
00226             return;
00227         }
00228 
00229         mMousePointer->setVisible(mVisible);
00230         mPointer = result->castType<IPointer>();
00231         mPointer->setImage(mMousePointer);
00232         mPointer->setPosition(mMousePointer, mPoint);
00233 
00234         mWidgetOwner = _owner;
00235     }
00236 
00237     void PointerManager::_unlinkWidget(WidgetPtr _widget)
00238     {
00239         if (_widget == mWidgetOwner) setPointer(mDefaultName, nullptr);
00240         else if (_widget == mMousePointer) mMousePointer = nullptr;
00241     }
00242 
00243     void PointerManager::resetToDefaultPointer()
00244     {
00245         //if (!mDefaultName.empty())
00246             setPointer(mDefaultName, nullptr);
00247     }
00248 
00249     // создает виджет
00250     WidgetPtr PointerManager::baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name)
00251     {
00252         WidgetPtr widget = WidgetManager::getInstance().createWidget(_style, _type, _skin, _coord, _align, nullptr, nullptr, this, _name);
00253         mWidgetChild.push_back(widget);
00254         // присоединяем виджет с уровню
00255         if (false == _layer.empty())
00256             LayerManager::getInstance().attachToLayerNode(_layer, widget);
00257         return widget;
00258     }
00259 
00260     // удяляет неудачника
00261     void PointerManager::_destroyChildWidget(WidgetPtr _widget)
00262     {
00263         MYGUI_ASSERT(nullptr != _widget, "invalid widget pointer");
00264 
00265         VectorWidgetPtr::iterator iter = std::find(mWidgetChild.begin(), mWidgetChild.end(), _widget);
00266         if (iter != mWidgetChild.end())
00267         {
00268             // сохраняем указатель
00269             MyGUI::WidgetPtr widget = *iter;
00270 
00271             // удаляем из списка
00272             *iter = mWidgetChild.back();
00273             mWidgetChild.pop_back();
00274 
00275             // отписываем от всех
00276             WidgetManager::getInstance().unlinkFromUnlinkers(_widget);
00277 
00278             // непосредственное удаление
00279             _deleteWidget(widget);
00280         }
00281         else
00282         {
00283             MYGUI_EXCEPT("Widget '" << _widget->getName() << "' not found");
00284         }
00285     }
00286 
00287     // удаляет всех детей
00288     void PointerManager::_destroyAllChildWidget()
00289     {
00290         WidgetManager& manager = WidgetManager::getInstance();
00291         while (false == mWidgetChild.empty())
00292         {
00293             // сразу себя отписывем, иначе вложенной удаление убивает все
00294             WidgetPtr widget = mWidgetChild.back();
00295             mWidgetChild.pop_back();
00296 
00297             // отписываем от всех
00298             manager.unlinkFromUnlinkers(widget);
00299 
00300             // и сами удалим, так как его больше в списке нет
00301             _deleteWidget(widget);
00302         }
00303     }
00304 
00305     void PointerManager::setDeafultPointer(const std::string& _value)
00306     {
00307         Update();
00308 
00309         mDefaultName = _value;
00310         setPointer(mDefaultName, nullptr);
00311     }
00312 
00313     void PointerManager::setLayerName(const std::string& _value)
00314     {
00315         Update();
00316 
00317         mLayerName = _value;
00318         if (LayerManager::getInstance().isExist(_value))
00319             LayerManager::getInstance().attachToLayerNode(mLayerName, mMousePointer);
00320     }
00321 
00322     void PointerManager::Update()
00323     {
00324         if (mMousePointer == nullptr)
00325         {
00326             mMousePointer = static_cast<StaticImagePtr>(baseCreateWidget(WidgetStyle::Overlapped, StaticImage::getClassTypeName(), "skin_Pointer", IntCoord(), Align::Default, "", ""));
00327             //setLayerName(mLayerName);
00328         }
00329         /*if (mPointer == nullptr)
00330         {
00331             setPointer(mDefaultName, nullptr);
00332         }*/
00333     }
00334 
00335     IPointer* PointerManager::getByName(const std::string& _name)
00336     {
00337         IResource* result = nullptr;
00338         if (!_name.empty() && _name != RESOURCE_DEFAULT_NAME)
00339             result = ResourceManager::getInstance().getByName(_name, false);
00340 
00341         if (result == nullptr)
00342             result = ResourceManager::getInstance().getByName(mDefaultName, false);
00343 
00344         return result ? result->castType<IPointer>(false) : nullptr;
00345     }
00346 
00347     void PointerManager::notifyChangeMouseFocus(WidgetPtr _widget)
00348     {
00349         std::string pointer = _widget == nullptr ? "" : _widget->getPointer();
00350         if (pointer != mCurrentMousePointer)
00351         {
00352             mCurrentMousePointer = pointer;
00353             if (mCurrentMousePointer.empty())
00354             {
00355                 resetToDefaultPointer();
00356                 eventChangeMousePointer(mDefaultName);
00357             }
00358             else
00359             {
00360                 setPointer(mCurrentMousePointer, _widget);
00361                 eventChangeMousePointer(mCurrentMousePointer);
00362             }
00363         }
00364     }
00365 
00366     void PointerManager::setPointer(const std::string& _name)
00367     {
00368         setPointer(_name, nullptr);
00369     }
00370 
00371 } // namespace MyGUI

Generated on Sun Jan 30 2011 for MyGUI by  doxygen 1.7.1