MyGUI  3.0.1
MyGUI_StaticImage.cpp
Go to the documentation of this file.
1 
7 /*
8  This file is part of MyGUI.
9 
10  MyGUI is free software: you can redistribute it and/or modify
11  it under the terms of the GNU Lesser General Public License as published by
12  the Free Software Foundation, either version 3 of the License, or
13  (at your option) any later version.
14 
15  MyGUI is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  GNU Lesser General Public License for more details.
19 
20  You should have received a copy of the GNU Lesser General Public License
21  along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
22 */
23 #include "MyGUI_Precompiled.h"
24 #include "MyGUI_StaticImage.h"
25 #include "MyGUI_CoordConverter.h"
26 #include "MyGUI_ResourceManager.h"
27 #include "MyGUI_ResourceSkin.h"
28 #include "MyGUI_RotatingSkin.h"
29 #include "MyGUI_Gui.h"
30 #include "MyGUI_TextureUtility.h"
31 
32 namespace MyGUI
33 {
34 
35  const size_t IMAGE_MAX_INDEX = 256;
36 
38  mIndexSelect(ITEM_NONE),
39  mFrameAdvise(false),
40  mCurrentTime(0),
41  mCurrentFrame(0),
42  mResource(nullptr)
43  {
44  }
45 
46  void StaticImage::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
47  {
48  Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
49 
50  initialiseWidgetSkin(_info);
51  }
52 
54  {
55  shutdownWidgetSkin();
56  }
57 
59  {
60  shutdownWidgetSkin();
62  initialiseWidgetSkin(_info);
63  }
64 
65  void StaticImage::initialiseWidgetSkin(ResourceSkin* _info)
66  {
67  // парсим свойства
68  const MapString& properties = _info->getProperties();
69  if ( ! properties.empty() )
70  {
71  MapString::const_iterator iter = properties.end();
72  if ((iter = properties.find("ImageTexture")) != properties.end()) setImageTexture(iter->second);
73  if ((iter = properties.find("ImageRect")) != properties.end()) setImageRect(IntRect::parse(iter->second));
74  if ((iter = properties.find("ImageCoord")) != properties.end()) setImageCoord(IntCoord::parse(iter->second));
75  if ((iter = properties.find("ImageTile")) != properties.end()) setImageTile(IntSize::parse(iter->second));
76  if ((iter = properties.find("ImageIndex")) != properties.end()) setImageIndex(utility::parseInt(iter->second));
77  if ((iter = properties.find("ImageResource")) != properties.end()) setItemResource(iter->second);
78  if ((iter = properties.find("ImageGroup")) != properties.end()) setItemGroup(iter->second);
79  if ((iter = properties.find("ImageName")) != properties.end()) setItemName(iter->second);
80  }
81  }
82 
83  void StaticImage::shutdownWidgetSkin()
84  {
85  frameAdvise(false);
86  }
87 
88  void StaticImage::setImageInfo(const std::string& _texture, const IntCoord& _coord, const IntSize& _tile)
89  {
90  mCurrentTextureName = _texture;
91  mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
92 
93  mSizeTile = _tile;
94  mRectImage.left = _coord.left;
95  mRectImage.top = _coord.top;
96  mRectImage.right = _coord.left + _coord.width;
97  mRectImage.bottom = _coord.top + _coord.height;
98 
99  recalcIndexes();
100  updateSelectIndex(mIndexSelect);
101  }
102 
104  {
105  mSizeTile = _tile;
106 
107  // если размер еще не установлен, то ставим тот что у тайла
108  if (mRectImage.empty()) mRectImage.set(0, 0, _tile.width, _tile.height);
109  //если индекса еще нет, то ставим 0
110  if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
111 
112  recalcIndexes();
113  updateSelectIndex(mIndexSelect);
114  }
115 
117  {
118  mRectImage.left = _coord.left;
119  mRectImage.top = _coord.top;
120  mRectImage.right = _coord.left + _coord.width;
121  mRectImage.bottom = _coord.top + _coord.height;
122 
123  // если тайл еще не установлен, то ставим тот что у координат
124  if (mSizeTile.empty()) mSizeTile = _coord.size();
125  //если индекса еще нет, то ставим 0
126  if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
127 
128  recalcIndexes();
129  updateSelectIndex(mIndexSelect);
130  }
131 
133  {
134  mRectImage= _rect;
135 
136  // если тайл еще не установлен, то ставим тот что у координат
137  if (mSizeTile.empty()) mSizeTile.set(_rect.width(), _rect.height());
138  //если индекса еще нет, то ставим 0
139  if (mIndexSelect == ITEM_NONE) mIndexSelect = 0;
140 
141  recalcIndexes();
142  updateSelectIndex(mIndexSelect);
143  }
144 
145  void StaticImage::setImageTexture(const std::string& _texture)
146  {
147  mCurrentTextureName = _texture;
148  mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
149 
150  // если первый раз, то ставим во всю текстуру
151  if (mItems.empty())
152  {
153  _setUVSet(FloatRect(0, 0, 1, 1));
154  _setTextureName(mCurrentTextureName);
155  }
156  else
157  {
158  recalcIndexes();
159  updateSelectIndex(mIndexSelect);
160  }
161  }
162 
163  void StaticImage::recalcIndexes()
164  {
165  mItems.clear();
166 
167  if ((mRectImage.right <= mRectImage.left) || (mRectImage.bottom <= mRectImage.top)) return;
168  if ((mSizeTile.width <= 0) || (mSizeTile.height <= 0)) return;
169 
170  size_t count_h = (size_t)(mRectImage.width() / mSizeTile.width);
171  size_t count_v = (size_t)(mRectImage.height() / mSizeTile.height);
172 
173  if ((count_h * count_v) > IMAGE_MAX_INDEX)
174  {
175  MYGUI_LOG(Warning, "Tile count very mach, rect : " << mRectImage.print() << " tile : " << mSizeTile.print() << " texture : " << mTextureName << " indexes : " << (count_h * count_v) << " max : " << IMAGE_MAX_INDEX);
176  return;
177  }
178 
179  int pos_h = mRectImage.left;
180  int pos_v = mRectImage.top;
181 
182  for (size_t v=0; v<count_v; ++v)
183  {
184  for (size_t h=0; h<count_h; ++h)
185  {
186  addItem(IntCoord(pos_h, pos_v, mSizeTile.width, mSizeTile.height));
187  pos_h += mSizeTile.width;
188  }
189  pos_v += mSizeTile.height;
190  pos_h = mRectImage.left;
191  }
192  }
193 
194  void StaticImage::updateSelectIndex(size_t _index)
195  {
196  mIndexSelect = _index;
197 
198  if ((_index == ITEM_NONE) || (_index >= mItems.size()))
199  {
200  _setTextureName("");
201  return;
202  }
203  else
204  {
205  _setTextureName(mCurrentTextureName);
206  }
207 
208  VectorImages::iterator iter = mItems.begin() + _index;
209 
210  if (iter->images.size() < 2)
211  {
212  frameAdvise(false);
213  }
214  else
215  {
216  if ( ! mFrameAdvise)
217  {
218  mCurrentTime = 0;
219  mCurrentFrame = 0;
220  }
221  frameAdvise(true);
222  }
223 
224  if ( ! iter->images.empty())
225  {
226  _setUVSet(iter->images.front());
227  }
228  }
229 
230  void StaticImage::deleteItem(size_t _index)
231  {
232  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::deleteItem");
233 
234  mItems.erase(mItems.begin() + _index);
235 
236  if (mIndexSelect != ITEM_NONE)
237  {
238  if (mItems.empty()) updateSelectIndex(ITEM_NONE);
239  else if ((_index < mIndexSelect) || (mIndexSelect == mItems.size())) updateSelectIndex(mIndexSelect--);
240  }
241  }
242 
244  {
245  updateSelectIndex(ITEM_NONE);
246  mItems.clear();
247  }
248 
249  void StaticImage::insertItem(size_t _index, const IntCoord& _item)
250  {
251  MYGUI_ASSERT_RANGE_INSERT(_index, mItems.size(), "StaticImage::insertItem");
252  if (_index == ITEM_NONE) _index = mItems.size();
253 
254  VectorImages::iterator iter = mItems.insert(mItems.begin() + _index, ImageItem());
255 
256  iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
257 
258  if ((mIndexSelect != ITEM_NONE) && (_index <= mIndexSelect)) updateSelectIndex(mIndexSelect++);
259  }
260 
261  void StaticImage::setItem(size_t _index, const IntCoord& _item)
262  {
263  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItem");
264 
265  VectorImages::iterator iter = mItems.begin() + _index;
266  iter->images.clear();
267  iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
268 
269  if (_index == mIndexSelect) updateSelectIndex(mIndexSelect);
270  }
271 
272  void StaticImage::frameEntered(float _frame)
273  {
274  if (mIndexSelect == ITEM_NONE) return;
275 
276  if (mItems.empty()) return;
277  VectorImages::iterator iter = mItems.begin() + mIndexSelect;
278  if ((iter->images.size() < 2) || (iter->frame_rate == 0)) return;
279 
280  mCurrentTime += _frame;
281 
282  while (mCurrentTime >= iter->frame_rate)
283  {
284  mCurrentTime -= iter->frame_rate;
285  mCurrentFrame ++;
286  if (mCurrentFrame >= (iter->images.size())) mCurrentFrame = 0;
287  }
288 
289  _setUVSet(iter->images[mCurrentFrame]);
290  }
291 
293  {
294  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::clearItemFrame");
295  VectorImages::iterator iter = mItems.begin() + _index;
296  iter->images.clear();
297  }
298 
299  void StaticImage::addItemFrame(size_t _index, const IntCoord& _item)
300  {
301  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::addItemFrame");
302  VectorImages::iterator iter = mItems.begin() + _index;
303  iter->images.push_back(CoordConverter::convertTextureCoord(_item, mSizeTexture));
304  }
305 
306  void StaticImage::setItemFrameRate(size_t _index, float _rate)
307  {
308  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItemFrameRate");
309  VectorImages::iterator iter = mItems.begin() + _index;
310  iter->frame_rate = _rate;
311  }
312 
313  float StaticImage::getItemFrameRate(size_t _index)
314  {
315  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::getItemFrameRate");
316  VectorImages::iterator iter = mItems.begin() + _index;
317  return iter->frame_rate;
318  }
319 
320  void StaticImage::addItemFrameDublicate(size_t _index, size_t _indexSourceFrame)
321  {
322  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::addItemFrameDublicate");
323 
324  VectorImages::iterator iter = mItems.begin() + _index;
325  MYGUI_ASSERT_RANGE(_indexSourceFrame, iter->images.size(), "StaticImage::addItemFrameDublicate");
326  iter->images.push_back(iter->images[_indexSourceFrame]);
327  }
328 
329  void StaticImage::insertItemFrame(size_t _index, size_t _indexFrame, const IntCoord& _item)
330  {
331  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::insertItemFrame");
332 
333  VectorImages::iterator iter = mItems.begin() + _index;
334  MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::insertItemFrame");
335  if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
336 
337  iter->images.insert(iter->images.begin() + _indexFrame,
338  CoordConverter::convertTextureCoord(_item, mSizeTexture));
339  }
340 
341  void StaticImage::insertItemFrameDublicate(size_t _index, size_t _indexFrame, size_t _indexSourceFrame)
342  {
343  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::insertItemFrameDublicate");
344 
345  VectorImages::iterator iter = mItems.begin() + _index;
346  MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::insertItemFrameDublicate");
347  if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
348 
349  MYGUI_ASSERT_RANGE(_indexSourceFrame, iter->images.size(), "StaticImage::insertItemFrameDublicate");
350 
351  iter->images.insert(iter->images.begin() + _indexFrame, iter->images[_indexSourceFrame]);
352  }
353 
354  void StaticImage::setItemFrame(size_t _index, size_t _indexFrame, const IntCoord& _item)
355  {
356  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::setItemFrame");
357 
358  VectorImages::iterator iter = mItems.begin() + _index;
359  MYGUI_ASSERT_RANGE(_indexFrame, iter->images.size(), "StaticImage::setItemFrame");
360 
361  iter->images[_indexFrame] = CoordConverter::convertTextureCoord(_item, mSizeTexture);
362  }
363 
364  void StaticImage::deleteItemFrame(size_t _index, size_t _indexFrame)
365  {
366  MYGUI_ASSERT_RANGE(_index, mItems.size(), "StaticImage::deleteItemFrame");
367 
368  VectorImages::iterator iter = mItems.begin() + _index;
369  MYGUI_ASSERT_RANGE_INSERT(_indexFrame, iter->images.size(), "StaticImage::deleteItemFrame");
370  if (_indexFrame == ITEM_NONE) _indexFrame = iter->images.size() - 1;
371 
372  iter->images.erase(iter->images.begin() + _indexFrame);
373  }
374 
376  {
377  mCurrentTextureName = _info.texture;
378  mSizeTexture = texture_utility::getTextureSize(mCurrentTextureName);
379 
380  mItems.clear();
381 
382  if (_info.frames.size() != 0)
383  {
384  std::vector<IntPoint>::const_iterator iter = _info.frames.begin();
385 
386  addItem(IntCoord(*iter, _info.size));
387  setItemFrameRate(0, _info.rate);
388 
389  for (++iter; iter!=_info.frames.end(); ++iter)
390  {
391  addItemFrame(0, MyGUI::IntCoord(*iter, _info.size));
392  }
393 
394  }
395 
396  mIndexSelect = 0;
397  updateSelectIndex(mIndexSelect);
398  }
399 
401  {
402  IResourcePtr resource = _id.empty() ? nullptr : ResourceManager::getInstance().getByID(_id, false);
403  setItemResourcePtr(resource ? resource->castType<ResourceImageSet>() : nullptr);
404  return resource != nullptr;
405  }
406 
407  bool StaticImage::setItemResource(const std::string& _name)
408  {
409  IResourcePtr resource = ResourceManager::getInstance().getByName(_name, false);
410  setItemResourcePtr(resource ? resource->castType<ResourceImageSet>() : nullptr);
411  return resource != nullptr;
412  }
413 
415  {
416  if (mResource == _resource)
417  return;
418 
419  // если первый раз то устанавливаем дефолтное
420  if (mResource == nullptr && _resource != nullptr)
421  {
422  if (mItemGroup.empty())
423  {
424  EnumeratorGroupImage iter_group = _resource->getEnumerator();
425  while (iter_group.next())
426  {
427  mItemGroup = iter_group.current().name;
428  if (mItemName.empty() && !iter_group.current().indexes.empty())
429  {
430  mItemName = iter_group.current().indexes[0].name;
431  }
432  break;
433  }
434  }
435  else if (mItemName.empty())
436  {
437  EnumeratorGroupImage iter_group = _resource->getEnumerator();
438  while (iter_group.next())
439  {
440  if (mItemGroup == iter_group.current().name)
441  {
442  if (!iter_group.current().indexes.empty())
443  {
444  mItemName = iter_group.current().indexes[0].name;
445  break;
446  }
447  }
448  }
449  }
450  }
451 
452  mResource = _resource;
453  if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
454  else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
455  }
456 
457  void StaticImage::setItemGroup(const std::string& _group)
458  {
459  if (mItemGroup == _group)
460  return;
461 
462  mItemGroup = _group;
463  if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
464  else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
465  }
466 
467  void StaticImage::setItemName(const std::string& _name)
468  {
469  if (mItemName == _name)
470  return;
471 
472  mItemName = _name;
473  if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
474  else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
475  }
476 
477  void StaticImage::setItemResourceInfo(ResourceImageSetPtr _resource, const std::string& _group, const std::string& _name)
478  {
479  mResource = _resource;
480  mItemGroup = _group;
481  mItemName = _name;
482  if (!mResource || mItemGroup.empty() || mItemName.empty()) updateSelectIndex(ITEM_NONE);
483  else setItemResourceInfo(mResource->getIndexInfo(mItemGroup, mItemName));
484  }
485 
486  void StaticImage::frameAdvise(bool _advise)
487  {
488  if ( _advise )
489  {
490  if ( ! mFrameAdvise )
491  {
492  MyGUI::Gui::getInstance().eventFrameStart += MyGUI::newDelegate( this, &StaticImage::frameEntered );
493  mFrameAdvise = true;
494  }
495  }
496  else
497  {
498  if ( mFrameAdvise )
499  {
500  MyGUI::Gui::getInstance().eventFrameStart -= MyGUI::newDelegate( this, &StaticImage::frameEntered );
501  mFrameAdvise = false;
502  }
503  }
504  }
505 
506  void StaticImage::setImageIndex(size_t _index)
507  {
508  setItemSelect(_index);
509  }
510 
512  {
513  return getItemSelect();
514  }
515 
516  void StaticImage::setItemSelect(size_t _index)
517  {
518  if (mIndexSelect != _index) updateSelectIndex(_index);
519  }
520 
521  void StaticImage::setProperty(const std::string& _key, const std::string& _value)
522  {
523  if (_key == "Image_Texture") setImageTexture(_value);
524  else if (_key == "Image_Coord") setImageCoord(utility::parseValue<IntCoord>(_value));
525  else if (_key == "Image_Tile") setImageTile(utility::parseValue<IntSize>(_value));
526  else if (_key == "Image_Index") setItemSelect(utility::parseValue<size_t>(_value));
527  else if (_key == "Image_Resource") setItemResource(_value);
528  else if (_key == "Image_Group") setItemGroup(_value);
529  else if (_key == "Image_Name") setItemName(_value);
530  else
531  {
532  Base::setProperty(_key, _value);
533  return;
534  }
535  eventChangeProperty(this, _key, _value);
536  }
537 
538 } // namespace MyGUI