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_StaticImage.h"
00025 #include "MyGUI_CoordConverter.h"
00026 #include "MyGUI_ResourceManager.h"
00027 #include "MyGUI_ResourceSkin.h"
00028 #include "MyGUI_RotatingSkin.h"
00029 #include "MyGUI_Gui.h"
00030 #include "MyGUI_TextureUtility.h"
00031
00032 namespace MyGUI
00033 {
00034
00035 const size_t IMAGE_MAX_INDEX = 256;
00036
00037 StaticImage::StaticImage() :
00038 mIndexSelect(ITEM_NONE),
00039 mFrameAdvise(false),
00040 mCurrentTime(0),
00041 mCurrentFrame(0),
00042 mResource(nullptr)
00043 {
00044 }
00045
00046 void StaticImage::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, WidgetPtr _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
00047 {
00048 Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
00049
00050 initialiseWidgetSkin(_info);
00051 }
00052
00053 StaticImage::~StaticImage()
00054 {
00055 shutdownWidgetSkin();
00056 }
00057
00058 void StaticImage::baseChangeWidgetSkin(ResourceSkin* _info)
00059 {
00060 shutdownWidgetSkin();
00061 Base::baseChangeWidgetSkin(_info);
00062 initialiseWidgetSkin(_info);
00063 }
00064
00065 void StaticImage::initialiseWidgetSkin(ResourceSkin* _info)
00066 {
00067
00068 const MapString& properties = _info->getProperties();
00069 if ( ! properties.empty() )
00070 {
00071 MapString::const_iterator iter = properties.end();
00072 if ((iter = properties.find("ImageTexture")) != properties.end()) setImageTexture(iter->second);
00073 if ((iter = properties.find("ImageRect")) != properties.end()) setImageRect(IntRect::parse(iter->second));
00074 if ((iter = properties.find("ImageCoord")) != properties.end()) setImageCoord(IntCoord::parse(iter->second));
00075 if ((iter = properties.find("ImageRot")) != properties.end()) setImageRot(utility::parseValue<float>(iter->second));
00076 if ((iter = properties.find("ImageRotCenter")) != properties.end()) setImageRotCenter(IntPoint::parse(iter->second));
00077 if ((iter = properties.find("ImageTile")) != properties.end()) setImageTile(IntSize::parse(iter->second));
00078 if ((iter = properties.find("ImageIndex")) != properties.end()) setImageIndex(utility::parseInt(iter->second));
00079 if ((iter = properties.find("ImageResource")) != properties.end()) setItemResource(iter->second);
00080 if ((iter = properties.find("ImageGroup")) != properties.end()) setItemGroup(iter->second);
00081 if ((iter = properties.find("ImageName")) != properties.end()) setItemName(iter->second);
00082 }
00083 }
00084
00085 void StaticImage::shutdownWidgetSkin()
00086 {
00087 frameAdvise(false);
00088 }
00089
00090 void StaticImage::setImageInfo(const std::string& _texture, const IntCoord& _coord, const IntSize& _tile)
00091 {
00092 mCurrentTextureName = _texture;
00093 mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
00094
00095 mSizeTile = _tile;
00096 mRectImage.left = _coord.left;
00097 mRectImage.top = _coord.top;
00098 mRectImage.right = _coord.left + _coord.width;
00099 mRectImage.bottom = _coord.top + _coord.height;
00100
00101 recalcIndexes();
00102 updateSelectIndex(mIndexSelect);
00103 }
00104
00105 void StaticImage::setImageTile(const IntSize& _tile)
00106 {
00107 mSizeTile = _tile;
00108
00109
00110 if (mRectImage.empty()) mRectImage.set(0, 0, _tile.width, _tile.height);
00111
00112 if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
00113
00114 recalcIndexes();
00115 updateSelectIndex(mIndexSelect);
00116 }
00117
00118 void StaticImage::setImageCoord(const IntCoord& _coord)
00119 {
00120 mRectImage.left = _coord.left;
00121 mRectImage.top = _coord.top;
00122 mRectImage.right = _coord.left + _coord.width;
00123 mRectImage.bottom = _coord.top + _coord.height;
00124
00125
00126 if (mSizeTile.empty()) mSizeTile = _coord.size();
00127
00128 if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
00129
00130 recalcIndexes();
00131 updateSelectIndex(mIndexSelect);
00132 }
00133
00134 void StaticImage::setImageRect(const IntRect& _rect)
00135 {
00136 mRectImage= _rect;
00137
00138
00139 if (mSizeTile.empty()) mSizeTile.set(_rect.width(), _rect.height());
00140
00141 if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
00142
00143 recalcIndexes();
00144 updateSelectIndex(mIndexSelect);
00145 }
00146
00147 void StaticImage::setImageTexture(const std::string& _texture)
00148 {
00149 mCurrentTextureName = _texture;
00150 mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
00151
00152
00153 if (mItems.empty())
00154 {
00155 _setUVSet(FloatRect(0, 0, 1, 1));
00156 _setTextureName(mCurrentTextureName);
00157 }
00158 else
00159 {
00160 recalcIndexes();
00161 updateSelectIndex(mIndexSelect);
00162 }
00163 }
00164
00165 void StaticImage::recalcIndexes()
00166 {
00167 mItems.clear();
00168
00169 if ((mRectImage.right <= mRectImage.left) || (mRectImage.bottom <= mRectImage.top)) return;
00170 if ((mSizeTile.width <= 0) || (mSizeTile.height <= 0)) return;
00171
00172 size_t count_h = (size_t)(mRectImage.width() / mSizeTile.width);
00173 size_t count_v = (size_t)(mRectImage.height() / mSizeTile.height);
00174
00175 if ((count_h * count_v) > IMAGE_MAX_INDEX) {
00176 MYGUI_LOG(Warning, "Tile count very mach, rect : " << mRectImage.print() << " tile : " << mSizeTile.print() << " texture : " << mTexture << " indexes : " << (count_h * count_v) << " max : " << IMAGE_MAX_INDEX);
00177 return;
00178 }
00179
00180 int pos_h = mRectImage.left;
00181 int pos_v = mRectImage.top;
00182
00183 for (size_t v=0; v<count_v; ++v) {
00184 for (size_t h=0; h<count_h; ++h) {
00185 addItem(IntCoord(pos_h, pos_v, mSizeTile.width, mSizeTile.height));
00186 pos_h += mSizeTile.width;
00187 }
00188 pos_v += mSizeTile.height;
00189 pos_h = mRectImage.left;
00190 }
00191 }
00192
00193 void StaticImage::updateSelectIndex(size_t _index)
00194 {
00195 mIndexSelect = _index;
00196
00197 if ((_index == ITEM_NONE) || (_index >= mItems.size()))
00198 {
00199 _setTextureName("");
00200 return;
00201 }
00202 else
00203 {
00204 _setTextureName(mCurrentTextureName);
00205 }
00206
00207 VectorImages::iterator iter = mItems.begin() + _index;
00208
00209 if (iter->images.size() < 2)
00210 {
00211 frameAdvise(false);
00212 }
00213 else
00214 {
00215 if ( ! mFrameAdvise)
00216 {
00217 mCurrentTime = 0;
00218 mCurrentFrame = 0;
00219 }
00220 frameAdvise(true);
00221 }
00222
00223 if ( ! iter->images.empty())
00224 {
00225 _setUVSet(iter->images.front());
00226 }
00227 }
00228
00229 void StaticImage::deleteItem(size_t _index)
00230 {
00231 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::deleteItem");
00232
00233 mItems.erase(mItems.begin() + _index);
00234
00235 if (mIndexSelect != ITEM_NONE) {
00236 if (mItems.empty()) updateSelectIndex(ITEM_NONE);
00237 else if ((_index < mIndexSelect) || (mIndexSelect == mItems.size())) updateSelectIndex(mIndexSelect--);
00238 }
00239 }
00240
00241 void StaticImage::deleteAllItems()
00242 {
00243 updateSelectIndex(ITEM_NONE);
00244 mItems.clear();
00245 }
00246
00247 void StaticImage::insertItem(size_t _index, const IntCoord& _item)
00248 {
00249 MYGUI_ASSERT_RANGE_INSERT(_index, mItems.size(), "StaticImage::insertItem");
00250 if (_index == ITEM_NONE) _index = mItems.size();
00251
00252 VectorImages::iterator iter = mItems.insert(mItems.begin() + _index, ImageItem());
00253
00254 iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
00255
00256 if ((mIndexSelect != ITEM_NONE) && (_index <= mIndexSelect)) updateSelectIndex(mIndexSelect++);
00257 }
00258
00259 void StaticImage::setItem(size_t _index, const IntCoord& _item)
00260 {
00261 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItem");
00262
00263 VectorImages::iterator iter = mItems.begin() + _index;
00264 iter->images.clear();
00265 iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
00266
00267 if (_index == mIndexSelect) updateSelectIndex(mIndexSelect);
00268 }
00269
00270 void StaticImage::frameEntered(float _frame)
00271 {
00272 if (mIndexSelect == ITEM_NONE) return;
00273
00274 if (mItems.empty()) return;
00275 VectorImages::iterator iter = mItems.begin() + mIndexSelect;
00276 if ((iter->images.size() < 2) || (iter->frame_rate == 0)) return;
00277
00278 mCurrentTime += _frame;
00279
00280 while (mCurrentTime >= iter->frame_rate) {
00281 mCurrentTime -= iter->frame_rate;
00282 mCurrentFrame ++;
00283 if (mCurrentFrame >= (iter->images.size())) mCurrentFrame = 0;
00284 }
00285
00286 _setUVSet(iter->images[mCurrentFrame]);
00287 }
00288
00289 void StaticImage::deleteAllItemFrames(size_t _index)
00290 {
00291 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::clearItemFrame");
00292 VectorImages::iterator iter = mItems.begin() + _index;
00293 iter->images.clear();
00294 }
00295
00296 void StaticImage::addItemFrame(size_t _index, const IntCoord& _item)
00297 {
00298 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::addItemFrame");
00299 VectorImages::iterator iter = mItems.begin() + _index;
00300 iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
00301 }
00302
00303 void StaticImage::setItemFrameRate(size_t _index, float _rate)
00304 {
00305 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItemFrameRate");
00306 VectorImages::iterator iter = mItems.begin() + _index;
00307 iter->frame_rate = _rate;
00308 }
00309
00310 float StaticImage::getItemFrameRate(size_t _index)
00311 {
00312 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::getItemFrameRate");
00313 VectorImages::iterator iter = mItems.begin() + _index;
00314 return iter->frame_rate;
00315 }
00316
00317 void StaticImage::addItemFrameDublicate(size_t _index, size_t _indexSourceFrame)
00318 {
00319 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::addItemFrameDublicate");
00320
00321 VectorImages::iterator iter = mItems.begin() + _index;
00322 MYGUI_ASSERT_RANGE(_indexSourceFrame, iter->images.size(), "StaticImage::addItemFrameDublicate");
00323 iter->images.push_back(iter->images[_indexSourceFrame]);
00324 }
00325
00326 void StaticImage::insertItemFrame(size_t _index, size_t _indexFrame, const IntCoord& _item)
00327 {
00328 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::insertItemFrame");
00329
00330 VectorImages::iterator iter = mItems.begin() + _index;
00331 MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::insertItemFrame");
00332 if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
00333
00334 iter->images.insert(iter->images.begin() + _indexFrame,
00335 CoordConverter::convertTextureCoord(_item, mSizeTexture));
00336 }
00337
00338 void StaticImage::insertItemFrameDublicate(size_t _index, size_t _indexFrame, size_t _indexSourceFrame)
00339 {
00340 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::insertItemFrameDublicate");
00341
00342 VectorImages::iterator iter = mItems.begin() + _index;
00343 MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::insertItemFrameDublicate");
00344 if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
00345
00346 MYGUI_ASSERT_RANGE(_indexSourceFrame, iter->images.size(), "StaticImage::insertItemFrameDublicate");
00347
00348 iter->images.insert(iter->images.begin() + _indexFrame, iter->images[_indexSourceFrame]);
00349 }
00350
00351 void StaticImage::setItemFrame(size_t _index, size_t _indexFrame, const IntCoord& _item)
00352 {
00353 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItemFrame");
00354
00355 VectorImages::iterator iter = mItems.begin() + _index;
00356 MYGUI_ASSERT_RANGE(_indexFrame, iter->images.size(), "StaticImage::setItemFrame");
00357
00358 iter->images[_indexFrame] = CoordConverter::convertTextureCoord(_item, mSizeTexture);
00359 }
00360
00361 void StaticImage::deleteItemFrame(size_t _index, size_t _indexFrame)
00362 {
00363 MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::deleteItemFrame");
00364
00365 VectorImages::iterator iter = mItems.begin() + _index;
00366 MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::deleteItemFrame");
00367 if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
00368
00369 iter->images.erase(iter->images.begin() + _indexFrame);
00370 }
00371
00372 void StaticImage::setItemResourceInfo(const ImageIndexInfo& _info)
00373 {
00374 mCurrentTextureName = _info.texture;
00375 mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
00376
00377 mItems.clear();
00378
00379 if (_info.frames.size() != 0) {
00380 std::vector<IntPoint>::const_iterator iter = _info.frames.begin();
00381
00382 addItem(IntCoord(*iter, _info.size));
00383 setItemFrameRate(0, _info.rate);
00384
00385 for (++iter; iter!=_info.frames.end(); ++iter) {
00386 addItemFrame(0, MyGUI::IntCoord(*iter, _info.size));
00387 }
00388
00389 }
00390
00391 mIndexSelect = 0;
00392 updateSelectIndex(mIndexSelect);
00393 }
00394
00395 bool StaticImage::setItemResource(const Guid& _id)
00396 {
00397 IResourcePtr resource = _id.empty() ? nullptr : ResourceManager::getInstance().getByID(_id, false);
00398 setItemResourcePtr(resource ? resource->castType<ResourceImageSet>() : nullptr);
00399 return resource != nullptr;
00400 }
00401
00402 bool StaticImage::setItemResource(const std::string& _name)
00403 {
00404 IResourcePtr resource = ResourceManager::getInstance().getByName(_name, false);
00405 setItemResourcePtr(resource ? resource->castType<ResourceImageSet>() : nullptr);
00406 return resource != nullptr;
00407 }
00408
00409 void StaticImage::setItemResourcePtr(ResourceImageSetPtr _resource)
00410 {
00411
00412 if (mResource == nullptr && _resource != nullptr)
00413 {
00414 if (mItemGroup.empty())
00415 {
00416 EnumeratorGroupImage iter_group = _resource->getEnumerator();
00417 while (iter_group.next())
00418 {
00419 mItemGroup = iter_group.current().name;
00420 if (mItemName.empty() && !iter_group.current().indexes.empty())
00421 {
00422 mItemName = iter_group.current().indexes[0].name;
00423 }
00424 break;
00425 }
00426 }
00427 else if (mItemName.empty())
00428 {
00429 EnumeratorGroupImage iter_group = _resource->getEnumerator();
00430 while (iter_group.next())
00431 {
00432 if (mItemGroup == iter_group.current().name)
00433 {
00434 if (!iter_group.current().indexes.empty())
00435 {
00436 mItemName = iter_group.current().indexes[0].name;
00437 break;
00438 }
00439 }
00440 }
00441 }
00442 }
00443
00444 mResource = _resource;
00445 if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
00446 else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
00447 }
00448
00449 void StaticImage::setItemGroup(const std::string& _group)
00450 {
00451 mItemGroup = _group;
00452 if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
00453 else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
00454 }
00455
00456 void StaticImage::setItemName(const std::string& _name)
00457 {
00458 mItemName = _name;
00459 if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
00460 else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
00461 }
00462
00463 void StaticImage::setItemResourceInfo(ResourceImageSetPtr _resource, const std::string& _group, const std::string& _name)
00464 {
00465 mResource = _resource;
00466 mItemGroup = _group;
00467 mItemName = _name;
00468 if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
00469 else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
00470 }
00471
00472 void StaticImage::frameAdvise(bool _advise)
00473 {
00474 if( _advise )
00475 {
00476 if( ! mFrameAdvise )
00477 {
00478 MyGUI::Gui::getInstance().eventFrameStart += MyGUI::newDelegate( this, &StaticImage::frameEntered );
00479 mFrameAdvise = true;
00480 }
00481 }
00482 else
00483 {
00484 if( mFrameAdvise )
00485 {
00486 MyGUI::Gui::getInstance().eventFrameStart -= MyGUI::newDelegate( this, &StaticImage::frameEntered );
00487 mFrameAdvise = false;
00488 }
00489 }
00490 }
00491
00492 void StaticImage::setImageIndex(size_t _index)
00493 {
00494 setItemSelect(_index);
00495 }
00496
00497 size_t StaticImage::getImageIndex()
00498 {
00499 return getItemSelect();
00500 }
00501
00502 void StaticImage::setImageRot(const float angle)
00503 {
00504 ISubWidget *main = getSubWidgetMain();
00505 if ( main && main->isType<RotatingSkin>() )
00506 main->castType<RotatingSkin>()->setAngle(angle);
00507 else MYGUI_LOG(Warning, "You must use skin with RotatingSkin main subskin (for example 'RotatingSkin')");
00508 }
00509
00510 void StaticImage::setImageRotCenter(const IntPoint &_center)
00511 {
00512 ISubWidget *main = getSubWidgetMain();
00513 if ( main && main->castType<RotatingSkin>(false) )
00514 main->castType<RotatingSkin>()->setCenter(_center);
00515 else MYGUI_LOG(Warning, "You must use skin with RotatingSkin main subskin (for example 'RotatingSkin')");
00516 }
00517
00518 void StaticImage::setItemSelect(size_t _index)
00519 {
00520 if (mIndexSelect != _index) updateSelectIndex(_index);
00521 }
00522
00523 void StaticImage::setProperty(const std::string& _key, const std::string& _value)
00524 {
00525 if (_key == "Image_Texture") setImageTexture(_value);
00526 else if (_key == "Image_Coord") setImageCoord(utility::parseValue<IntCoord>(_value));
00527 else if (_key == "Image_Tile") setImageTile(utility::parseValue<IntSize>(_value));
00528 else if (_key == "Image_Index") setItemSelect(utility::parseValue<size_t>(_value));
00529 else if (_key == "Image_Resource") setItemResource(_value);
00530 else if (_key == "Image_Group") setItemGroup(_value);
00531 else if (_key == "Image_Name") setItemName(_value);
00532 else if (_key == "Image_Rotation") setImageRot(utility::parseValue<float>(_value));
00533 else if (_key == "Image_RotationCenter") setImageRotCenter(utility::parseValue<IntPoint>(_value));
00534 else Base::setProperty(_key, _value);
00535 }
00536
00537 }