00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
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
00068
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
00105
00106
00107
00108 xml::ElementEnumerator node = _node->getElementEnumerator();
00109 while (node.next())
00110 {
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178 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
00190
00191
00192
00193
00194
00195
00196
00197
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
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
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
00328 }
00329
00330
00331
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 }