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

MyGUI_StaticImage.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_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         //если индекса еще нет, то ставим 0
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         //если индекса еще нет, то ставим 0
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         //если индекса еще нет, то ставим 0
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 } // namespace MyGUI

Generated on Sun Jan 30 2011 for MyGUI by  doxygen 1.7.1