Merge branch 'next' into water

Conflicts:
	CMakeLists.txt

CMakeLists.txt

@@ -177,7 +177,6 @@ include_directories(${UUID_INCLUDE_DIR})
 endif (WIN32)
 if (MSVC10)
     set(PLATFORM_INCLUDE_DIR "")
-    add_definitions(-DMYGUI_DONT_REPLACE_NULLPTR)
 endif()
 
 if (APPLE)
@@ -186,7 +185,13 @@ endif (APPLE)
 
 # Dependencies
 
+# Fix for not visible pthreads functions for linker with glibc 2.15 
+if (UNIX AND NOT APPLE)
+find_package (Threads)
+endif()
+
 find_package(OGRE REQUIRED)
+find_package(MyGUI REQUIRED)
 find_package(Boost REQUIRED COMPONENTS system filesystem program_options thread)
 find_package(OIS REQUIRED)
 find_package(OpenAL REQUIRED)
@@ -203,14 +208,14 @@ include_directories("."
     ${OGRE_INCLUDE_DIR} ${OGRE_INCLUDE_DIR}/Ogre ${OGRE_INCLUDE_DIR}/OGRE ${OGRE_PLUGIN_INCLUDE_DIRS}
     ${OIS_INCLUDE_DIRS} ${Boost_INCLUDE_DIR}
     ${PLATFORM_INCLUDE_DIR}
-    ${CMAKE_HOME_DIRECTORY}/extern/mygui_3.0.1/MyGUIEngine/include
+    ${MYGUI_INCLUDE_DIRS}
-    ${CMAKE_HOME_DIRECTORY}/extern/mygui_3.0.1/OgrePlatform/include
+    ${MYGUI_PLATFORM_INCLUDE_DIRS}
     ${OPENAL_INCLUDE_DIR}
     ${UUID_INCLUDE_DIR}
     ${LIBDIR}
 )
 
-link_directories(${Boost_LIBRARY_DIRS} ${OGRE_LIB_DIR})
+link_directories(${Boost_LIBRARY_DIRS} ${OGRE_LIB_DIR} ${MYGUI_LIB_DIR})
 
 if(APPLE)
     # List used Ogre plugins
@@ -220,15 +225,8 @@ if(APPLE)
                           "Plugin_ParticleFX")
 endif(APPLE)
 
-add_subdirectory( extern/mygui_3.0.1 )
 add_subdirectory( files/)
-
+add_subdirectory( files/mygui )
-# Make sure that certain libraries are used as static libraries
-# This is in effect turns off __declspec (dllexport) for windows
-# Each library will also need to be configured to build as a static lib
-
-# MyGUI: extern/mygui_3.0.0/
-add_definitions(-DMYGUI_STATIC)
 
 # Specify build paths
 
@@ -323,7 +321,7 @@ if(DPKG_PROGRAM)
     SET(CPACK_DEBIAN_PACKAGE_NAME "openmw")
     SET(CPACK_DEBIAN_PACKAGE_VERSION "${VERSION_STRING}")
     SET(CPACK_PACKAGE_EXECUTABLES "openmw;OpenMW esmtool;Esmtool omwlauncher;OMWLauncher")
-    SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libogre-1.7.3 (>= 1.7.3), libbullet0 (>= 2.77),  libboost-filesystem1.46.1 (>= 1.46.1), libboost-program-options1.46.1 (>= 1.46.1), libboost-system1.46.1 (>= 1.46.1), libboost-thread1.46.1 (>= 1.46.1), libc6 (>= 2.11.2), libfreetype6 (>= 2.2.1), libgcc1 (>= 1:4.1.1), libmpg123-0 (>= 1.12.1), libois-1.3.0 (>= 1.3.0), libopenal1 (>= 1:1.12.854), libsndfile1 (>= 1.0.23), libstdc++6 (>= 4.4.5), libuuid1 (>= 2.17.2), libqtgui4 (>= 4.7.0)")
+    SET(CPACK_DEBIAN_PACKAGE_DEPENDS "nvidia-cg-toolkit (>= 2.1),  libboost-filesystem1.46.1 (>= 1.46.1), libboost-program-options1.46.1 (>= 1.46.1), libboost-system1.46.1 (>= 1.46.1), libboost-thread1.46.1 (>= 1.46.1), libc6 (>= 2.11.2), libfreetype6 (>= 2.2.1), libgcc1 (>= 1:4.1.1), libmpg123-0 (>= 1.12.1), libois-1.3.0 (>= 1.3.0), libopenal1 (>= 1:1.12.854), libsndfile1 (>= 1.0.23), libstdc++6 (>= 4.4.5), libuuid1 (>= 2.17.2), libqtgui4 (>= 4.7.0)")
 
     SET(CPACK_DEBIAN_PACKAGE_SECTION "Games")
 
@@ -459,7 +457,9 @@ if (WIN32)
     endforeach(d)
 
     set_target_properties(components PROPERTIES COMPILE_FLAGS ${WARNINGS})
-    set_target_properties(omwlauncher PROPERTIES COMPILE_FLAGS ${WARNINGS})
+    if (BUILD_LAUNCHER)
+		set_target_properties(omwlauncher PROPERTIES COMPILE_FLAGS ${WARNINGS})
+	endif (BUILD_LAUNCHER)
     set_target_properties(openmw PROPERTIES COMPILE_FLAGS ${WARNINGS})
   endif(MSVC)
 

apps/launcher/datafilespage.cpp

@@ -222,7 +222,7 @@ void DataFilesPage::setupDataFiles()
 
         QMessageBox msgBox;
         msgBox.setWindowTitle("Error detecting Morrowind installation");
-        msgBox.setIcon(QMessageBox::Critical);
+        msgBox.setIcon(QMessageBox::Warning);
         msgBox.setStandardButtons(QMessageBox::Cancel);
         msgBox.setText(tr("<br><b>Could not find the Data Files location</b><br><br> \
         The directory containing the Data Files was not found.<br><br> \
@@ -279,72 +279,79 @@ void DataFilesPage::setupDataFiles()
     const Files::MultiDirCollection &esp = fileCollections.getCollection(".esp");
 
     for (Files::MultiDirCollection::TIter iter(esp.begin()); iter!=esp.end(); ++iter) {
-        ESMReader fileReader;
-        QStringList availableMasters; // Will contain all found masters
 
-        fileReader.setEncoding(variables["encoding"].as<std::string>());
+        try {
-        fileReader.open(iter->second.string());
+            ESMReader fileReader;
+            QStringList availableMasters; // Will contain all found masters
 
-        // First we fill the availableMasters and the mMastersWidget
+            fileReader.setEncoding(variables["encoding"].as<std::string>());
-        ESMReader::MasterList mlist = fileReader.getMasters();
+            fileReader.open(iter->second.string());
 
-        for (unsigned int i = 0; i < mlist.size(); ++i) {
+            // First we fill the availableMasters and the mMastersWidget
-            const QString currentMaster = QString::fromStdString(mlist[i].name);
+            ESMReader::MasterList mlist = fileReader.getMasters();
-            availableMasters.append(currentMaster);
 
-            const QList<QTableWidgetItem*> itemList = mMastersWidget->findItems(currentMaster, Qt::MatchExactly);
+            for (unsigned int i = 0; i < mlist.size(); ++i) {
+                const QString currentMaster = QString::fromStdString(mlist[i].name);
+                availableMasters.append(currentMaster);
 
-            if (itemList.isEmpty()) { // Master is not yet in the widget
+                const QList<QTableWidgetItem*> itemList = mMastersWidget->findItems(currentMaster, Qt::MatchExactly);
-                mMastersWidget->insertRow(i);
 
-                QTableWidgetItem *item = new QTableWidgetItem(currentMaster);
+                if (itemList.isEmpty()) { // Master is not yet in the widget
-                item->setForeground(Qt::red);
+                    mMastersWidget->insertRow(i);
-                item->setFlags(item->flags() & ~(Qt::ItemIsSelectable));
 
-                mMastersWidget->setItem(i, 0, item);
+                    QTableWidgetItem *item = new QTableWidgetItem(currentMaster);
+                    item->setForeground(Qt::red);
+                    item->setFlags(item->flags() & ~(Qt::ItemIsSelectable));
+
+                    mMastersWidget->setItem(i, 0, item);
+                }
             }
-        }
 
-        availableMasters.sort(); // Sort the masters alphabetically
+            availableMasters.sort(); // Sort the masters alphabetically
 
-        // Now we put the current plugin in the mDataFilesModel under its masters
+            // Now we put the current plugin in the mDataFilesModel under its masters
-        QStandardItem *parent = new QStandardItem(availableMasters.join(","));
+            QStandardItem *parent = new QStandardItem(availableMasters.join(","));
 
-        QString fileName = QString::fromStdString(boost::filesystem::path (iter->second.filename()).string());
+            QString fileName = QString::fromStdString(boost::filesystem::path (iter->second.filename()).string());
-        QStandardItem *child = new QStandardItem(fileName);
+            QStandardItem *child = new QStandardItem(fileName);
 
-        // Tooltip information
+            // Tooltip information
-        QString author = QString::fromStdString(fileReader.getAuthor());
+            QString author = QString::fromStdString(fileReader.getAuthor());
-        float version = fileReader.getFVer();
+            float version = fileReader.getFVer();
-        QString description = QString::fromStdString(fileReader.getDesc());
+            QString description = QString::fromStdString(fileReader.getDesc());
 
-        // For the date created/modified
+            // For the date created/modified
-        QFileInfo fi(QString::fromStdString(iter->second.string()));
+            QFileInfo fi(QString::fromStdString(iter->second.string()));
 
-        QString toolTip= QString("<b>Author:</b> %1<br/> \
+            QString toolTip= QString("<b>Author:</b> %1<br/> \
-                                <b>Version:</b> %2<br/><br/> \
+                                    <b>Version:</b> %2<br/><br/> \
-                                <b>Description:</b><br/> \
+                                    <b>Description:</b><br/> \
-                                %3<br/><br/> \
+                                    %3<br/><br/> \
-                                <b>Created on:</b> %4<br/> \
+                                    <b>Created on:</b> %4<br/> \
-                                <b>Last modified:</b> %5")
+                                    <b>Last modified:</b> %5")
-                            .arg(author)
+                                .arg(author)
-                            .arg(version)
+                                .arg(version)
-                            .arg(description)
+                                .arg(description)
-                            .arg(fi.created().toString(Qt::TextDate))
+                                .arg(fi.created().toString(Qt::TextDate))
-                            .arg(fi.lastModified().toString(Qt::TextDate));
+                                .arg(fi.lastModified().toString(Qt::TextDate));
 
-        child->setToolTip(toolTip);
+            child->setToolTip(toolTip);
 
-        const QList<QStandardItem*> masterList = mDataFilesModel->findItems(availableMasters.join(","));
+            const QList<QStandardItem*> masterList = mDataFilesModel->findItems(availableMasters.join(","));
 
-        if (masterList.isEmpty()) { // Masters node not yet in the mDataFilesModel
+            if (masterList.isEmpty()) { // Masters node not yet in the mDataFilesModel
-            parent->appendRow(child);
+                parent->appendRow(child);
-            mDataFilesModel->appendRow(parent);
+                mDataFilesModel->appendRow(parent);
-        } else {
+            } else {
-            // Masters node exists, append current plugin
+                // Masters node exists, append current plugin
-            foreach (QStandardItem *currentItem, masterList) {
+                foreach (QStandardItem *currentItem, masterList) {
-                currentItem->appendRow(child);
+                    currentItem->appendRow(child);
+                }
             }
+
+        } catch(std::runtime_error &e) {
+            // An error occurred while reading the .esp
+            continue;
         }
     }
 

apps/openmw/CMakeLists.txt

@@ -48,7 +48,7 @@ add_openmw_dir (mwsound
 add_openmw_dir (mwworld
     refdata world physicssystem scene environment globals class action nullaction actionteleport
     containerstore actiontalk actiontake manualref player cellfunctors
-    cells localscripts customdata weather inventorystore
+    cells localscripts customdata weather inventorystore ptr
     )
 
 add_openmw_dir (mwclass
@@ -85,17 +85,22 @@ add_definitions(${SOUND_DEFINE})
 
 target_link_libraries(openmw
     ${OGRE_LIBRARIES}
-	${OGRE_STATIC_PLUGINS}
+    ${OGRE_STATIC_PLUGINS}
     ${OIS_LIBRARIES}
     ${Boost_LIBRARIES}
     ${OPENAL_LIBRARY}
     ${SOUND_INPUT_LIBRARY}
     ${BULLET_LIBRARIES}
+    ${MYGUI_LIBRARIES}
+    MyGUI.OgrePlatform #TODO MyGUI ogre platform is not added by the find script
     components
-    MyGUIEngine
-    MyGUIOgrePlatform
 )
 
+# Fix for not visible pthreads functions for linker with glibc 2.15
+if (UNIX AND NOT APPLE)
+target_link_libraries(openmw ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
 if(APPLE)
     find_library(CARBON_FRAMEWORK Carbon)
     target_link_libraries(openmw ${CARBON_FRAMEWORK})

apps/openmw/engine.cpp

@@ -60,7 +60,7 @@ void OMW::Engine::executeLocalScripts()
 
         MWScript::InterpreterContext interpreterContext (mEnvironment,
             &script.second.getRefData().getLocals(), script.second);
-        mScriptManager->run (script.first, interpreterContext);
+        mEnvironment.mScriptManager->run (script.first, interpreterContext);
 
         if (mEnvironment.mWorld->hasCellChanged())
             break;
@@ -182,7 +182,6 @@ OMW::Engine::Engine(Files::ConfigurationManager& configurationManager)
   , mCompileAll (false)
   , mReportFocus (false)
   , mFocusTDiff (0)
-  , mScriptManager (0)
   , mScriptContext (0)
   , mFSStrict (false)
   , mCfgMgr(configurationManager)
@@ -199,7 +198,7 @@ OMW::Engine::~Engine()
     delete mEnvironment.mMechanicsManager;
     delete mEnvironment.mDialogueManager;
     delete mEnvironment.mJournal;
-    delete mScriptManager;
+    delete mEnvironment.mScriptManager;
     delete mScriptContext;
     delete mOgre;
 }
@@ -352,18 +351,18 @@ void OMW::Engine::go()
         mEnvironment);
     mScriptContext->setExtensions (&mExtensions);
 
-    mScriptManager = new MWScript::ScriptManager (mEnvironment.mWorld->getStore(), mVerboseScripts,
+    mEnvironment.mScriptManager = new MWScript::ScriptManager (mEnvironment.mWorld->getStore(),
-        *mScriptContext);
+        mVerboseScripts, *mScriptContext);
 
     mEnvironment.mGlobalScripts = new MWScript::GlobalScripts (mEnvironment.mWorld->getStore(),
-        *mScriptManager);
+        *mEnvironment.mScriptManager);
 
     // Create game mechanics system
     mEnvironment.mMechanicsManager = new MWMechanics::MechanicsManager (mEnvironment);
 
     // Create dialog system
     mEnvironment.mJournal = new MWDialogue::Journal (mEnvironment);
-    mEnvironment.mDialogueManager = new MWDialogue::DialogueManager (mEnvironment);
+    mEnvironment.mDialogueManager = new MWDialogue::DialogueManager (mEnvironment,mExtensions);
 
     // load cell
     ESM::Position pos;
@@ -397,7 +396,7 @@ void OMW::Engine::go()
     // scripts
     if (mCompileAll)
     {
-        std::pair<int, int> result = mScriptManager->compileAll();
+        std::pair<int, int> result = mEnvironment.mScriptManager->compileAll();
 
         if (result.first)
             std::cout
@@ -442,7 +441,7 @@ void OMW::Engine::activate()
     if (!script.empty())
     {
         mEnvironment.mWorld->getLocalScripts().setIgnore (ptr);
-        mScriptManager->run (script, interpreterContext);
+        mEnvironment.mScriptManager->run (script, interpreterContext);
     }
 
     if (!interpreterContext.hasActivationBeenHandled())

apps/openmw/engine.hpp

@@ -78,10 +78,9 @@ namespace OMW
             std::string mFocusName;
 
             MWWorld::Environment mEnvironment;
-            MWScript::ScriptManager *mScriptManager;
             Compiler::Extensions mExtensions;
             Compiler::Context *mScriptContext;
-            
+
 
             Files::Collections mFileCollections;
             bool mFSStrict;

apps/openmw/mwdialogue/dialoguemanager.cpp

@@ -9,16 +9,36 @@
 
 #include <components/esm_store/store.hpp>
 
+
 #include "../mwworld/class.hpp"
 #include "../mwworld/environment.hpp"
 #include "../mwworld/world.hpp"
 #include "../mwworld/refdata.hpp"
 #include "../mwworld/player.hpp"
+#include "../mwworld/containerstore.hpp"
 
 #include "../mwinput/inputmanager.hpp"
+#include "../mwgui/dialogue.hpp"
+#include "../mwgui/window_manager.hpp"
+
+#include "journal.hpp"
 
 #include <iostream>
 
+#include "../mwscript/extensions.hpp"
+#include "../mwscript/scriptmanager.hpp"
+
+#include <components/compiler/exception.hpp>
+#include <components/compiler/errorhandler.hpp>
+#include <components/compiler/scanner.hpp>
+#include <components/compiler/locals.hpp>
+#include <components/compiler/output.hpp>
+#include <components/interpreter/interpreter.hpp>
+
+#include "../mwscript/compilercontext.hpp"
+#include "../mwscript/interpretercontext.hpp"
+#include <components/compiler/scriptparser.hpp>
+
 namespace
 {
     std::string toLower (const std::string& name)
@@ -31,17 +51,18 @@ namespace
         return lowerCase;
     }
 
+
     template<typename T1, typename T2>
     bool selectCompare (char comp, T1 value1, T2 value2)
     {
         switch (comp)
         {
-            case '0': return value1==value2;
+        case '0': return value1==value2;
-            case '1': return value1!=value2;
+        case '1': return value1!=value2;
-            case '2': return value1>value2;
+        case '2': return value1>value2;
-            case '3': return value1>=value2;
+        case '3': return value1>=value2;
-            case '4': return value1<value2;
+        case '4': return value1<value2;
-            case '5': return value1<=value2;
+        case '5': return value1<=value2;
         }
 
         throw std::runtime_error ("unknown compare type in dialogue info select");
@@ -87,26 +108,26 @@ namespace
     {
         switch (world.getGlobalVariableType (name))
         {
-            case 's':
+        case 's':
 
-                return selectCompare (comp, value, world.getGlobalVariable (name).mShort);
+            return selectCompare (comp, value, world.getGlobalVariable (name).mShort);
 
-            case 'l':
+        case 'l':
 
-                return selectCompare (comp, value, world.getGlobalVariable (name).mLong);
+            return selectCompare (comp, value, world.getGlobalVariable (name).mLong);
 
-            case 'f':
+        case 'f':
 
-                return selectCompare (comp, value, world.getGlobalVariable (name).mFloat);
+            return selectCompare (comp, value, world.getGlobalVariable (name).mFloat);
 
-            case ' ':
+        case ' ':
 
-                world.getGlobalVariable (name); // trigger exception
+            world.getGlobalVariable (name); // trigger exception
-                break;
+            break;
 
-            default:
+        default:
 
-                throw std::runtime_error ("unsupported gobal variable type");
+            throw std::runtime_error ("unsupported gobal variable type");
         }
 
         return false;
@@ -115,6 +136,125 @@ namespace
 
 namespace MWDialogue
 {
+
+    //helper function
+    std::string::size_type find_str_ci(const std::string& str, const std::string& substr,size_t pos)
+    {
+        return toLower(str).find(toLower(substr),pos);
+    }
+
+    bool DialogueManager::functionFilter(const MWWorld::Ptr& actor, const ESM::DialInfo& info,bool choice)
+    {
+        for (std::vector<ESM::DialInfo::SelectStruct>::const_iterator iter (info.selects.begin());
+            iter != info.selects.end(); ++iter)
+        {
+            ESM::DialInfo::SelectStruct select = *iter;
+            char type = select.selectRule[1];
+            if(type == '1')
+            {
+                char comp = select.selectRule[4];
+                std::string name = select.selectRule.substr (5);
+                std::string function = select.selectRule.substr(2,2);
+
+                int ifunction;
+                std::istringstream iss(function);
+                iss >> ifunction;
+                switch(ifunction)
+                {
+                case 39://PC Expelled
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 40://PC Common Disease
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 41://PC Blight Disease
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 43://PC Crime level
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 46://Same faction
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 48://Detected
+                    if(!selectCompare<int,int>(comp,1,select.i)) return false;
+                    break;
+
+                case 49://Alarmed
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 50://choice
+
+                    if(choice)
+                    {
+                        if(!selectCompare<int,int>(comp,mChoice,select.i)) return false;
+                    }
+                    break;
+
+                case 60://PC Vampire
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 61://Level
+                    if(!selectCompare<int,int>(comp,1,select.i)) return false;
+                    break;
+
+                case 62://Attacked
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 63://Talked to PC
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 64://PC Health
+                    if(!selectCompare<int,int>(comp,50,select.i)) return false;
+                    break;
+
+                case 65://Creature target
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 66://Friend hit
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 67://Fight
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 68://Hello????
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 69://Alarm
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 70://Flee
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                case 71://Should Attack
+                    if(!selectCompare<int,int>(comp,0,select.i)) return false;
+                    break;
+
+                default:
+                    break;
+
+                }
+            }
+        }
+
+        return true;
+    }
+
     bool DialogueManager::isMatching (const MWWorld::Ptr& actor,
         const ESM::DialInfo::SelectStruct& select) const
     {
@@ -124,58 +264,173 @@ namespace MWDialogue
         {
             char comp = select.selectRule[4];
             std::string name = select.selectRule.substr (5);
-
+            std::string function = select.selectRule.substr(1,2);
-            // TODO types 4, 5, 6, 7, 8, 9, A, B, C
 
             switch (type)
             {
-                case '1': // function
+            case '1': // function
 
-                    return false; // TODO implement functions
+                return true; // TODO implement functions
 
-                case '2': // global
+            case '2': // global
 
-                    if (select.type==ESM::VT_Short || select.type==ESM::VT_Int ||
+                if (select.type==ESM::VT_Short || select.type==ESM::VT_Int ||
-                        select.type==ESM::VT_Long)
+                    select.type==ESM::VT_Long)
-                    {
+                {
-                        if (!checkGlobal (comp, toLower (name), select.i, *mEnvironment.mWorld))
+                    if (!checkGlobal (comp, toLower (name), select.i, *mEnvironment.mWorld))
-                            return false;
+                        return false;
-                    }
+                }
-                    else if (select.type==ESM::VT_Float)
+                else if (select.type==ESM::VT_Float)
-                    {
+                {
-                        if (!checkGlobal (comp, toLower (name), select.f, *mEnvironment.mWorld))
+                    if (!checkGlobal (comp, toLower (name), select.f, *mEnvironment.mWorld))
-                            return false;
+                        return false;
-                    }
+                }
-                    else
+                else
-                        throw std::runtime_error (
+                    throw std::runtime_error (
-                            "unsupported variable type in dialogue info select");
+                    "unsupported variable type in dialogue info select");
 
-                    return true;
+                return true;
 
-                case '3': // local
+            case '3': // local
 
-                    if (select.type==ESM::VT_Short || select.type==ESM::VT_Int ||
+                if (select.type==ESM::VT_Short || select.type==ESM::VT_Int ||
-                        select.type==ESM::VT_Long)
+                    select.type==ESM::VT_Long)
-                    {
+                {
-                        if (!checkLocal (comp, toLower (name), select.i, actor,
+                    if (!checkLocal (comp, toLower (name), select.i, actor,
-                            mEnvironment.mWorld->getStore()))
+                        mEnvironment.mWorld->getStore()))
-                            return false;
+                        return false;
-                    }
+                }
-                    else if (select.type==ESM::VT_Float)
+                else if (select.type==ESM::VT_Float)
-                    {
+                {
-                        if (!checkLocal (comp, toLower (name), select.f, actor,
+                    if (!checkLocal (comp, toLower (name), select.f, actor,
-                            mEnvironment.mWorld->getStore()))
+                        mEnvironment.mWorld->getStore()))
-                            return false;
+                        return false;
-                    }
+                }
-                    else
+                else
-                        throw std::runtime_error (
+                    throw std::runtime_error (
-                            "unsupported variable type in dialogue info select");
+                    "unsupported variable type in dialogue info select");
 
-                    return true;
+                return true;
 
-                default:
+            case '4'://journal
+                if(select.type==ESM::VT_Int)
+                {
+                    if(!selectCompare<int,int>(comp,mEnvironment.mJournal->getJournalIndex(toLower(name)),select.i)) return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
 
-                    std::cout << "unchecked select: " << type << " " << comp << " " << name << std::endl;
+                return true;
+
+            case '5'://item
+                {
+                MWWorld::Ptr player = mEnvironment.mWorld->getPlayer().getPlayer();
+                MWWorld::ContainerStore& store = MWWorld::Class::get (player).getContainerStore (player);
+
+                int sum = 0;
+
+                for (MWWorld::ContainerStoreIterator iter (store.begin()); iter!=store.end(); ++iter)
+                    if (iter->getCellRef().refID==name)
+                        sum += iter->getRefData().getCount();
+                if(!selectCompare<int,int>(comp,sum,select.i)) return false;
+                }
+
+                return true;
+
+
+            case '6'://dead
+                if(!selectCompare<int,int>(comp,0,select.i)) return false;
+
+            case '7':// not ID
+                if(select.type==ESM::VT_String ||select.type==ESM::VT_Int)//bug in morrowind here? it's not a short, it's a string
+                {
+                    int isID = int(toLower(name)==toLower(MWWorld::Class::get (actor).getId (actor)));
+                    if (selectCompare<int,int>(comp,!isID,select.i)) return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+
+                return true;
+
+            case '8':// not faction
+                if(select.type==ESM::VT_Int)
+                {
+                    ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData>* npc = actor.get<ESM::NPC>();
+                    int isFaction = int(toLower(npc->base->faction) == toLower(name));
+                    if(selectCompare<int,int>(comp,!isFaction,select.i))
+                        return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+
+                return true;
+
+            case '9':// not class
+                if(select.type==ESM::VT_Int)
+                {
+                    ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData>* npc = actor.get<ESM::NPC>();
+                    int isClass = int(toLower(npc->base->cls) == toLower(name));
+                    if(selectCompare<int,int>(comp,!isClass,select.i))
+                        return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+
+                return true;
+
+            case 'A'://not Race
+                if(select.type==ESM::VT_Int)
+                {
+                    ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData>* npc = actor.get<ESM::NPC>();
+                    int isRace = int(toLower(npc->base->race) == toLower(name));
+                    if(selectCompare<int,int>(comp,!isRace,select.i))
+                        return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+
+                return true;
+
+            case 'B'://not Cell
+                if(select.type==ESM::VT_Int)
+                {
+                    int isCell = int(toLower(actor.getCell()->cell->name) == toLower(name));
+                    if(selectCompare<int,int>(comp,!isCell,select.i))
+                        return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+                return true;
+
+            case 'C'://not local
+                if (select.type==ESM::VT_Short || select.type==ESM::VT_Int ||
+                    select.type==ESM::VT_Long)
+                {
+                    if (checkLocal (comp, toLower (name), select.i, actor,
+                        mEnvironment.mWorld->getStore()))
+                        return false;
+                }
+                else if (select.type==ESM::VT_Float)
+                {
+                    if (checkLocal (comp, toLower (name), select.f, actor,
+                        mEnvironment.mWorld->getStore()))
+                        return false;
+                }
+                else
+                    throw std::runtime_error (
+                    "unsupported variable type in dialogue info select");
+                return true;
+
+
+            default:
+
+                std::cout << "unchecked select: " << type << " " << comp << " " << name << std::endl;
             }
         }
 
@@ -189,6 +444,10 @@ namespace MWDialogue
             if (toLower (info.actor)!=MWWorld::Class::get (actor).getId (actor))
                 return false;
 
+        //PC Faction
+        if(!info.pcFaction.empty()) return false;
+
+        //NPC race
         if (!info.race.empty())
         {
             ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData> *cellRef = actor.get<ESM::NPC>();
@@ -200,6 +459,7 @@ namespace MWDialogue
                 return false;
         }
 
+        //NPC class
         if (!info.clas.empty())
         {
             ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData> *cellRef = actor.get<ESM::NPC>();
@@ -211,6 +471,7 @@ namespace MWDialogue
                 return false;
         }
 
+        //NPC faction
         if (!info.npcFaction.empty())
         {
             ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData> *cellRef = actor.get<ESM::NPC>();
@@ -220,66 +481,320 @@ namespace MWDialogue
 
             if (toLower (info.npcFaction)!=toLower (cellRef->base->faction))
                 return false;
+
+            //check NPC rank
+            if(cellRef->base->npdt52.gold != -10)
+            {
+                if(cellRef->base->npdt52.rank < info.data.rank) return false;
+            }
+            else
+            {
+                if(cellRef->base->npdt12.rank < info.data.rank) return false;
+            }
         }
 
         // TODO check player faction
 
+        //check gender
+        ESMS::LiveCellRef<ESM::NPC, MWWorld::RefData>* npc = actor.get<ESM::NPC>();
+        if(npc->base->flags&npc->base->Female)
+        {
+            if(static_cast<int> (info.data.gender)==0)  return false;
+        }
+        else
+        {
+            if(static_cast<int> (info.data.gender)==1)  return false;
+        }
+
+
         // check cell
         if (!info.cell.empty())
             if (mEnvironment.mWorld->getPlayer().getPlayer().getCell()->cell->name != info.cell)
                 return false;
 
         // TODO check DATAstruct
-
         for (std::vector<ESM::DialInfo::SelectStruct>::const_iterator iter (info.selects.begin());
             iter != info.selects.end(); ++iter)
             if (!isMatching (actor, *iter))
                 return false;
 
-        std::cout
-            << "unchecked entries:" << std::endl
-            << "    player faction: " << info.pcFaction << std::endl
-            << "    disposition: " << info.data.disposition << std::endl
-            << "    NPC rank: " << static_cast<int> (info.data.rank) << std::endl
-            << "    gender: " << static_cast<int> (info.data.gender) << std::endl
-            << "    PC rank: " << static_cast<int> (info.data.PCrank) << std::endl;
-
         return true;
     }
 
-    DialogueManager::DialogueManager (MWWorld::Environment& environment) : mEnvironment (environment) {}
+    DialogueManager::DialogueManager (MWWorld::Environment& environment,const Compiler::Extensions& extensions) :
+    mEnvironment (environment),mCompilerContext (MWScript::CompilerContext::Type_Dialgoue, environment),
+        mErrorStream(std::cout.rdbuf()),mErrorHandler(mErrorStream)
+    {
+        mChoice = -1;
+        mIsInChoice = false;
+        mCompilerContext.setExtensions (&extensions);
+    }
+
+    void DialogueManager::addTopic(std::string topic)
+    {
+        knownTopics[toLower(topic)] = true;
+    }
+
+    void DialogueManager::parseText(std::string text)
+    {
+        std::list<std::string>::iterator it;
+        for(it = actorKnownTopics.begin();it != actorKnownTopics.end();it++)
+        {
+            size_t pos = find_str_ci(text,*it,0);
+            if(pos !=std::string::npos)
+            {
+                if(pos==0)
+                {
+                    knownTopics[*it] = true;
+                }
+                else if(text.substr(pos -1,1) == " ")
+                {
+                    knownTopics[*it] = true;
+                }
+            }
+        }
+        updateTopics();
+    }
 
     void DialogueManager::startDialogue (const MWWorld::Ptr& actor)
     {
-        std::cout << "talking with " << MWWorld::Class::get (actor).getName (actor) << std::endl;
+        mChoice = -1;
+        mIsInChoice = false;
 
-        const ESM::Dialogue *dialogue = mEnvironment.mWorld->getStore().dialogs.find ("hello");
+        mActor = actor;
 
-        for (std::vector<ESM::DialInfo>::const_iterator iter (dialogue->mInfo.begin());
+        mDialogueMap.clear();
-            iter!=dialogue->mInfo.end(); ++iter)
+        actorKnownTopics.clear();
+        ESMS::RecListT<ESM::Dialogue>::MapType dialogueList = mEnvironment.mWorld->getStore().dialogs.list;
+        for(ESMS::RecListT<ESM::Dialogue>::MapType::iterator it = dialogueList.begin(); it!=dialogueList.end();it++)
         {
-            if (isMatching (actor, *iter))
+            mDialogueMap[it->first] = it->second;
+        }
+
+        //initialise the GUI
+        mEnvironment.mInputManager->setGuiMode(MWGui::GM_Dialogue);
+        MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+        win->startDialogue(MWWorld::Class::get (actor).getName (actor));
+
+        //setup the list of topics known by the actor. Topics who are also on the knownTopics list will be added to the GUI
+        updateTopics();
+
+        //greeting
+        bool greetingFound = false;
+        //ESMS::RecListT<ESM::Dialogue>::MapType dialogueList = mEnvironment.mWorld->getStore().dialogs.list;
+        for(ESMS::RecListT<ESM::Dialogue>::MapType::iterator it = dialogueList.begin(); it!=dialogueList.end();it++)
+        {
+            ESM::Dialogue ndialogue = it->second;
+            if(ndialogue.type == ESM::Dialogue::Greeting)
             {
-                // start dialogue
+                if (greetingFound) break;
-                std::cout << "found matching info record" << std::endl;
+                for (std::vector<ESM::DialInfo>::const_iterator iter (it->second.mInfo.begin());
-
+                    iter!=it->second.mInfo.end(); ++iter)
-                std::cout << "response: " << iter->response << std::endl;
-
-                if (!iter->sound.empty())
                 {
-                    // TODO play sound
+                    if (isMatching (actor, *iter) && functionFilter(mActor,*iter,true))
-                }
+                    {
+                        if (!iter->sound.empty())
+                        {
+                            // TODO play sound
+                        }
 
-                if (!iter->resultScript.empty())
+                        std::string text = iter->response;
-                {
+                        parseText(text);
-                    std::cout << "script: " << iter->resultScript << std::endl;
+                        win->addText(iter->response);
-                    // TODO execute script
+                        executeScript(iter->resultScript);
+                        greetingFound = true;
+                        mLastTopic = it->first;
+                        mLastDialogue = *iter;
+                        break;
+                    }
                 }
-
-                mEnvironment.mInputManager->setGuiMode(MWGui::GM_Dialogue);
-                break;
             }
         }
     }
 
+    bool DialogueManager::compile (const std::string& cmd,std::vector<Interpreter::Type_Code>& code)
+    {
+        try
+        {
+            mErrorHandler.reset();
+
+            std::istringstream input (cmd + "\n");
+
+            Compiler::Scanner scanner (mErrorHandler, input, mCompilerContext.getExtensions());
+
+            Compiler::Locals locals;
+
+            std::string actorScript = MWWorld::Class::get (mActor).getScript (mActor);
+
+            if (!actorScript.empty())
+            {
+                // grab local variables from actor's script, if available.
+                locals = mEnvironment.mScriptManager->getLocals (actorScript);
+            }
+
+            Compiler::ScriptParser parser(mErrorHandler,mCompilerContext, locals, false);
+
+            scanner.scan (parser);
+            if(mErrorHandler.isGood())
+            {
+                parser.getCode(code);
+                return true;
+            }
+            return false;
+        }
+        catch (const Compiler::SourceException& error)
+        {
+            // error has already been reported via error handler
+        }
+        catch (const std::exception& error)
+        {
+            printError (std::string ("An exception has been thrown: ") + error.what());
+        }
+
+        return false;
+    }
+
+    void DialogueManager::executeScript(std::string script)
+    {
+        std::vector<Interpreter::Type_Code> code;
+        if(compile(script,code))
+        {
+            try
+            {
+                MWScript::InterpreterContext interpreterContext(mEnvironment,&mActor.getRefData().getLocals(),mActor);
+                Interpreter::Interpreter interpreter;
+                MWScript::installOpcodes (interpreter);
+                interpreter.run (&code[0], code.size(), interpreterContext);
+            }
+            catch (const std::exception& error)
+            {
+                printError (std::string ("An exception has been thrown: ") + error.what());
+            }
+        }
+    }
+
+    void DialogueManager::updateTopics()
+    {
+        std::list<std::string> keywordList;
+        int choice = mChoice;
+        mChoice = -1;
+        actorKnownTopics.clear();
+        MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+        ESMS::RecListT<ESM::Dialogue>::MapType dialogueList = mEnvironment.mWorld->getStore().dialogs.list;
+        for(ESMS::RecListT<ESM::Dialogue>::MapType::iterator it = dialogueList.begin(); it!=dialogueList.end();it++)
+        {
+            ESM::Dialogue ndialogue = it->second;
+            if(ndialogue.type == ESM::Dialogue::Topic)
+            {
+                for (std::vector<ESM::DialInfo>::const_iterator iter (it->second.mInfo.begin());
+                    iter!=it->second.mInfo.end(); ++iter)
+                {
+                    if (isMatching (mActor, *iter) && functionFilter(mActor,*iter,true))
+                    {
+                         actorKnownTopics.push_back(it->first);
+                        //does the player know the topic?
+                        if(knownTopics.find(toLower(it->first)) != knownTopics.end())
+                        {
+                            keywordList.push_back(it->first);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        win->setKeywords(keywordList);
+        mChoice = choice;
+    }
+
+    void DialogueManager::keywordSelected(std::string keyword)
+    {
+        if(!mIsInChoice)
+        {
+            if(mDialogueMap.find(keyword) != mDialogueMap.end())
+            {
+                ESM::Dialogue ndialogue = mDialogueMap[keyword];
+                if(ndialogue.type == ESM::Dialogue::Topic)
+                {
+                    for (std::vector<ESM::DialInfo>::const_iterator iter  = ndialogue.mInfo.begin();
+                        iter!=ndialogue.mInfo.end(); ++iter)
+                    {
+                        if (isMatching (mActor, *iter) && functionFilter(mActor,*iter,true))
+                        {
+                            std::string text = iter->response;
+                            std::string script = iter->resultScript;
+
+                            parseText(text);
+
+                            MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+                            win->addTitle(keyword);
+                            win->addText(iter->response);
+
+                            executeScript(script);
+
+                            mLastTopic = keyword;
+                            mLastDialogue = *iter;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        updateTopics();
+    }
+
+    void DialogueManager::goodbyeSelected()
+    {
+        mEnvironment.mInputManager->setGuiMode(MWGui::GM_Game);
+    }
+
+    void DialogueManager::questionAnswered(std::string answere)
+    {
+        if(mChoiceMap.find(answere) != mChoiceMap.end())
+        {
+            mChoice = mChoiceMap[answere];
+
+            std::vector<ESM::DialInfo>::const_iterator iter;
+            if(mDialogueMap.find(mLastTopic) != mDialogueMap.end())
+            {
+                ESM::Dialogue ndialogue = mDialogueMap[mLastTopic];
+                if(ndialogue.type == ESM::Dialogue::Topic)
+                {
+                    for (std::vector<ESM::DialInfo>::const_iterator iter = ndialogue.mInfo.begin();
+                        iter!=ndialogue.mInfo.end(); ++iter)
+                    {
+                        if (isMatching (mActor, *iter) && functionFilter(mActor,*iter,true))
+                        {
+                            mChoiceMap.clear();
+                            mChoice = -1;
+                            mIsInChoice = false;
+                            MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+                            std::string text = iter->response;
+                            parseText(text);
+                            win->addText(text);
+                            executeScript(iter->resultScript);
+                            mLastTopic = mLastTopic;
+                            mLastDialogue = *iter;
+                            break;
+                        }
+                    }
+                }
+            }
+            updateTopics();
+        }
+    }
+
+    void DialogueManager::printError(std::string error)
+    {
+        MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+        win->addText(error);
+    }
+
+    void DialogueManager::askQuestion(std::string question, int choice)
+    {
+        MWGui::DialogueWindow* win = mEnvironment.mWindowManager->getDialogueWindow();
+        win->askQuestion(question);
+        mChoiceMap[question] = choice;
+        mIsInChoice = true;
+    }
 }

apps/openmw/mwdialogue/dialoguemanager.hpp

@@ -3,7 +3,13 @@
 
 #include <components/esm/loadinfo.hpp>
 
+#include <components/compiler/streamerrorhandler.hpp>
+#include "../mwscript/compilercontext.hpp"
+#include "../mwscript/interpretercontext.hpp"
+#include <components/compiler/output.hpp>
+
 #include "../mwworld/ptr.hpp"
+#include <map>
 
 namespace MWWorld
 {
@@ -20,12 +26,48 @@ namespace MWDialogue
 
             bool isMatching (const MWWorld::Ptr& actor, const ESM::DialInfo& info) const;
 
+            bool functionFilter(const MWWorld::Ptr& actor, const ESM::DialInfo& info,bool choice);
+
+            void parseText(std::string text);
+
+            void updateTopics();
+
+            std::map<std::string,ESM::Dialogue> mDialogueMap;
+            std::map<std::string,bool> knownTopics;// Those are the topics the player knows.
+            std::list<std::string> actorKnownTopics;
+
+            MWScript::CompilerContext mCompilerContext;
+            std::ostream mErrorStream;
+            Compiler::StreamErrorHandler mErrorHandler;
+            
+
+            bool compile (const std::string& cmd,std::vector<Interpreter::Type_Code>& code);
+            void executeScript(std::string script);
+            MWWorld::Ptr mActor;
+
+            void printError(std::string error);
+
+            int mChoice;
+            std::map<std::string,int> mChoiceMap;
+            std::string mLastTopic;
+            ESM::DialInfo mLastDialogue;
+            bool mIsInChoice;
+
         public:
 
-            DialogueManager (MWWorld::Environment& environment);
+            DialogueManager (MWWorld::Environment& environment,const Compiler::Extensions& extensions);
 
             void startDialogue (const MWWorld::Ptr& actor);
 
+            void addTopic(std::string topic);
+
+            void askQuestion(std::string question,int choice);
+
+            //calbacks for the GUI
+            void keywordSelected(std::string keyword);
+            void goodbyeSelected();
+            void questionAnswered(std::string answere);
+
     };
 }
 

apps/openmw/mwdialogue/journal.cpp

@@ -3,6 +3,9 @@
 
 #include "../mwworld/environment.hpp"
 
+#include "../mwgui/window_manager.hpp"
+#include "../mwgui/messagebox.hpp"
+
 namespace MWDialogue
 {
     Quest& Journal::getQuest (const std::string& id)
@@ -34,6 +37,10 @@ namespace MWDialogue
         Quest& quest = getQuest (id);
 
         quest.addEntry (entry, *mEnvironment.mWorld); // we are doing slicing on purpose here
+        
+        std::vector<std::string> empty;
+        std::string notification = "Your Journal has been updated.";
+        mEnvironment.mWindowManager->messageBox (notification, empty);
     }
 
     void Journal::setJournalIndex (const std::string& id, int index)
@@ -60,7 +67,12 @@ namespace MWDialogue
 
     int Journal::getJournalIndex (const std::string& id) const
     {
-        return 0;
+        TQuestContainer::const_iterator iter = mQuests.find (id);
+
+        if (iter==mQuests.end())
+            return 0;
+
+        return iter->second.getIndex();
     }
 
     Journal::TEntryIter Journal::begin() const

apps/openmw/mwgui/birth.cpp

@@ -21,18 +21,18 @@ BirthDialog::BirthDialog(WindowManager& parWindowManager)
 
     getWidget(birthList, "BirthsignList");
     birthList->setScrollVisible(true);
-    birthList->eventListSelectAccept = MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
+    birthList->eventListSelectAccept += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
-    birthList->eventListMouseItemActivate = MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
+    birthList->eventListMouseItemActivate += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
-    birthList->eventListChangePosition = MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
+    birthList->eventListChangePosition += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &BirthDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BirthDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &BirthDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BirthDialog::onOkClicked);
 
     updateBirths();
     updateSpells();
@@ -100,7 +100,7 @@ void BirthDialog::onBackClicked(MyGUI::Widget* _sender)
     eventBack();
 }
 
-void BirthDialog::onSelectBirth(MyGUI::List* _sender, size_t _index)
+void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
 {
     if (_index == MyGUI::ITEM_NONE)
         return;
@@ -188,7 +188,7 @@ void BirthDialog::updateSpells()
     {
         if (!categories[category].spells.empty())
         {
-            MyGUI::StaticTextPtr label = spellArea->createWidget<MyGUI::StaticText>("SandBrightText", coord, MyGUI::Align::Default, std::string("Label"));
+            MyGUI::TextBox* label = spellArea->createWidget<MyGUI::TextBox>("SandBrightText", coord, MyGUI::Align::Default, std::string("Label"));
             label->setCaption(mWindowManager.getGameSettingString(categories[category].label, ""));
             spellItems.push_back(label);
             coord.top += lineHeight;

apps/openmw/mwgui/birth.hpp

@@ -32,7 +32,7 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Back button clicked.\n
             signature : void method()\n
@@ -40,7 +40,7 @@ namespace MWGui
         EventHandle_Void eventBack;
 
     protected:
-        void onSelectBirth(MyGUI::List* _sender, size_t _index);
+        void onSelectBirth(MyGUI::ListBox* _sender, size_t _index);
 
         void onOkClicked(MyGUI::Widget* _sender);
         void onBackClicked(MyGUI::Widget* _sender);
@@ -49,9 +49,9 @@ namespace MWGui
         void updateBirths();
         void updateSpells();
 
-        MyGUI::ListPtr    birthList;
+        MyGUI::ListBox*    birthList;
         MyGUI::WidgetPtr  spellArea;
-        MyGUI::StaticImagePtr birthImage;
+        MyGUI::ImageBox* birthImage;
         std::vector<MyGUI::WidgetPtr> spellItems;
 
         std::string currentBirthId;

apps/openmw/mwgui/charactercreation.cpp

@@ -121,7 +121,7 @@ void CharacterCreation::spawnDialog(const char id)
             mNameDialog->setTextLabel(mWM->getGameSettingString("sName", "Name"));
             mNameDialog->setTextInput(mPlayerName);
             mNameDialog->setNextButtonShow(mCreationStage >= CSE_NameChosen);
-            mNameDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onNameDialogDone);
+            mNameDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onNameDialogDone);
             mNameDialog->open();
             break;
 
@@ -131,8 +131,8 @@ void CharacterCreation::spawnDialog(const char id)
             mRaceDialog = new RaceDialog(*mWM);
             mRaceDialog->setNextButtonShow(mCreationStage >= CSE_RaceChosen);
             mRaceDialog->setRaceId(mPlayerRaceId);
-            mRaceDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogDone);
+            mRaceDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogDone);
-            mRaceDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogBack);
+            mRaceDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onRaceDialogBack);
             mRaceDialog->open();
             break;
 
@@ -140,7 +140,7 @@ void CharacterCreation::spawnDialog(const char id)
             if (mClassChoiceDialog)
                 mWM->removeDialog(mClassChoiceDialog);
             mClassChoiceDialog = new ClassChoiceDialog(*mWM);
-            mClassChoiceDialog->eventButtonSelected = MyGUI::newDelegate(this, &CharacterCreation::onClassChoice);
+            mClassChoiceDialog->eventButtonSelected += MyGUI::newDelegate(this, &CharacterCreation::onClassChoice);
             mClassChoiceDialog->open();
             break;
 
@@ -150,8 +150,8 @@ void CharacterCreation::spawnDialog(const char id)
             mPickClassDialog = new PickClassDialog(*mWM);
             mPickClassDialog->setNextButtonShow(mCreationStage >= CSE_ClassChosen);
             mPickClassDialog->setClassId(mPlayerClass.name);
-            mPickClassDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogDone);
+            mPickClassDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogDone);
-            mPickClassDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogBack);
+            mPickClassDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onPickClassDialogBack);
             mPickClassDialog->open();
             break;
 
@@ -161,8 +161,8 @@ void CharacterCreation::spawnDialog(const char id)
             mBirthSignDialog = new BirthDialog(*mWM);
             mBirthSignDialog->setNextButtonShow(mCreationStage >= CSE_BirthSignChosen);
             mBirthSignDialog->setBirthId(mPlayerBirthSignId);
-            mBirthSignDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogDone);
+            mBirthSignDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogDone);
-            mBirthSignDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogBack);
+            mBirthSignDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onBirthSignDialogBack);
             mBirthSignDialog->open();
             break;
 
@@ -170,8 +170,8 @@ void CharacterCreation::spawnDialog(const char id)
             if (mCreateClassDialog)
                 mWM->removeDialog(mCreateClassDialog);
             mCreateClassDialog = new CreateClassDialog(*mWM);
-            mCreateClassDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogDone);
+            mCreateClassDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogDone);
-            mCreateClassDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogBack);
+            mCreateClassDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onCreateClassDialogBack);
             mCreateClassDialog->open();
             break;
         case GM_ClassGenerate:
@@ -212,9 +212,9 @@ void CharacterCreation::spawnDialog(const char id)
                 mReviewDialog->configureSkills(mPlayerMajorSkills, mPlayerMinorSkills);
             }
 
-            mReviewDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogDone);
+            mReviewDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogDone);
-            mReviewDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogBack);
+            mReviewDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onReviewDialogBack);
-            mReviewDialog->eventActivateDialog = MyGUI::newDelegate(this, &CharacterCreation::onReviewActivateDialog);
+            mReviewDialog->eventActivateDialog += MyGUI::newDelegate(this, &CharacterCreation::onReviewActivateDialog);
             mReviewDialog->open();
             break;
     }
@@ -559,8 +559,8 @@ void CharacterCreation::showClassQuestionDialog()
             mWM->removeDialog(mGenerateClassResultDialog);
         mGenerateClassResultDialog = new GenerateClassResultDialog(*mWM);
         mGenerateClassResultDialog->setClassId(mGenerateClass);
-        mGenerateClassResultDialog->eventBack = MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassBack);
+        mGenerateClassResultDialog->eventBack += MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassBack);
-        mGenerateClassResultDialog->eventDone = MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassDone);
+        mGenerateClassResultDialog->eventDone += MyGUI::newDelegate(this, &CharacterCreation::onGenerateClassDone);
         mGenerateClassResultDialog->open();
         return;
     }
@@ -581,7 +581,7 @@ void CharacterCreation::showClassQuestionDialog()
     buttons.push_back(sGenerateClassSteps[mGenerateClassStep].mButtons[1]);
     buttons.push_back(sGenerateClassSteps[mGenerateClassStep].mButtons[2]);
     mGenerateClassQuestionDialog->setButtons(buttons);
-    mGenerateClassQuestionDialog->eventButtonSelected = MyGUI::newDelegate(this, &CharacterCreation::onClassQuestionChosen);
+    mGenerateClassQuestionDialog->eventButtonSelected += MyGUI::newDelegate(this, &CharacterCreation::onClassQuestionChosen);
     mGenerateClassQuestionDialog->open();
 }
 

apps/openmw/mwgui/class.cpp

@@ -29,11 +29,11 @@ GenerateClassResultDialog::GenerateClassResultDialog(WindowManager& parWindowMan
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &GenerateClassResultDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &GenerateClassResultDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &GenerateClassResultDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &GenerateClassResultDialog::onOkClicked);
 }
 
 void GenerateClassResultDialog::open()
@@ -96,20 +96,20 @@ PickClassDialog::PickClassDialog(WindowManager& parWindowManager)
 
     getWidget(classList, "ClassList");
     classList->setScrollVisible(true);
-    classList->eventListSelectAccept = MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
+    classList->eventListSelectAccept += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
-    classList->eventListMouseItemActivate = MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
+    classList->eventListMouseItemActivate += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
-    classList->eventListChangePosition = MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
+    classList->eventListChangePosition += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
 
     getWidget(classImage, "ClassImage");
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &PickClassDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &PickClassDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &PickClassDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &PickClassDialog::onOkClicked);
 
     updateClasses();
     updateStats();
@@ -177,7 +177,7 @@ void PickClassDialog::onBackClicked(MyGUI::Widget* _sender)
     eventBack();
 }
 
-void PickClassDialog::onSelectClass(MyGUI::List* _sender, size_t _index)
+void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
 {
     if (_index == MyGUI::ITEM_NONE)
         return;
@@ -248,7 +248,7 @@ void PickClassDialog::updateStats()
 
 /* InfoBoxDialog */
 
-void InfoBoxDialog::fitToText(MyGUI::StaticTextPtr widget)
+void InfoBoxDialog::fitToText(MyGUI::TextBox* widget)
 {
     MyGUI::IntCoord inner = widget->getTextRegion();
     MyGUI::IntCoord outer = widget->getCoord();
@@ -267,7 +267,7 @@ void InfoBoxDialog::layoutVertically(MyGUI::WidgetPtr widget, int margin)
     for (unsigned i = 0; i < count; ++i)
     {
         MyGUI::WidgetPtr child = widget->getChildAt(i);
-        if (!child->isVisible())
+        if (!child->getVisible())
             continue;
 
         child->setPosition(child->getLeft(), pos);
@@ -322,7 +322,7 @@ void InfoBoxDialog::setButtons(ButtonList &buttons)
         button->getSubWidgetText()->setWordWrap(true);
         button->setCaption(text);
         fitToText(button);
-        button->eventMouseButtonClick = MyGUI::newDelegate(this, &InfoBoxDialog::onButtonClicked);
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &InfoBoxDialog::onButtonClicked);
         coord.top += button->getHeight();
         this->buttons.push_back(button);
     }
@@ -389,15 +389,15 @@ CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
     setText("SpecializationT", mWindowManager.getGameSettingString("sChooseClassMenu1", "Specialization"));
     getWidget(specializationName, "SpecializationName");
     specializationName->setCaption(mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Combat], ""));
-    specializationName->eventMouseButtonClick = MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationClicked);
+    specializationName->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationClicked);
 
     setText("FavoriteAttributesT", mWindowManager.getGameSettingString("sChooseClassMenu2", "Favorite Attributes:"));
     getWidget(favoriteAttribute0, "FavoriteAttribute0");
     getWidget(favoriteAttribute1, "FavoriteAttribute1");
     favoriteAttribute0->setWindowManager(&mWindowManager);
     favoriteAttribute1->setWindowManager(&mWindowManager);
-    favoriteAttribute0->eventClicked = MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
+    favoriteAttribute0->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
-    favoriteAttribute1->eventClicked = MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
+    favoriteAttribute1->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
 
     setText("MajorSkillT", mWindowManager.getGameSettingString("sSkillClassMajor", ""));
     setText("MinorSkillT", mWindowManager.getGameSettingString("sSkillClassMinor", ""));
@@ -414,7 +414,7 @@ CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
     for (std::vector<Widgets::MWSkillPtr>::const_iterator it = skills.begin(); it != end; ++it)
     {
         (*it)->setWindowManager(&mWindowManager);
-        (*it)->eventClicked = MyGUI::newDelegate(this, &CreateClassDialog::onSkillClicked);
+        (*it)->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onSkillClicked);
     }
 
     setText("LabelT", mWindowManager.getGameSettingString("sName", ""));
@@ -426,15 +426,15 @@ CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr descriptionButton;
     getWidget(descriptionButton, "DescriptionButton");
-    descriptionButton->eventMouseButtonClick = MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionClicked);
+    descriptionButton->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionClicked);
 
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &CreateClassDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &CreateClassDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onOkClicked);
 
     // Set default skills, attributes
 
@@ -560,8 +560,8 @@ void CreateClassDialog::onSpecializationClicked(MyGUI::WidgetPtr _sender)
     if (specDialog)
         delete specDialog;
     specDialog = new SelectSpecializationDialog(mWindowManager);
-    specDialog->eventCancel = MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
+    specDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
-    specDialog->eventItemSelected = MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationSelected);
+    specDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationSelected);
     specDialog->setVisible(true);
 }
 
@@ -578,8 +578,8 @@ void CreateClassDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
         delete attribDialog;
     attribDialog = new SelectAttributeDialog(mWindowManager);
     attribDialog->setAffectedWidget(_sender);
-    attribDialog->eventCancel = MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
+    attribDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
-    attribDialog->eventItemSelected = MyGUI::newDelegate(this, &CreateClassDialog::onAttributeSelected);
+    attribDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeSelected);
     attribDialog->setVisible(true);
 }
 
@@ -607,8 +607,8 @@ void CreateClassDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
         delete skillDialog;
     skillDialog = new SelectSkillDialog(mWindowManager);
     skillDialog->setAffectedWidget(_sender);
-    skillDialog->eventCancel = MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
+    skillDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
-    skillDialog->eventItemSelected = MyGUI::newDelegate(this, &CreateClassDialog::onSkillSelected);
+    skillDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSkillSelected);
     skillDialog->setVisible(true);
 }
 
@@ -638,7 +638,7 @@ void CreateClassDialog::onDescriptionClicked(MyGUI::Widget* _sender)
 {
     descDialog = new DescriptionDialog(mWindowManager);
     descDialog->setTextInput(description);
-    descDialog->eventDone = MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionEntered);
+    descDialog->eventDone += MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionEntered);
     descDialog->setVisible(true);
 }
 
@@ -672,18 +672,18 @@ SelectSpecializationDialog::SelectSpecializationDialog(WindowManager& parWindowM
     getWidget(specialization1, "Specialization1");
     getWidget(specialization2, "Specialization2");
     specialization0->setCaption(mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Combat], ""));
-    specialization0->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
+    specialization0->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
     specialization1->setCaption(mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Magic], ""));
-    specialization1->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
+    specialization1->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
     specialization2->setCaption(mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Stealth], ""));
-    specialization2->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
+    specialization2->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
     specializationId = ESM::Class::Combat;
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr cancelButton;
     getWidget(cancelButton, "CancelButton");
     cancelButton->setCaption(mWindowManager.getGameSettingString("sCancel", ""));
-    cancelButton->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectSpecializationDialog::onCancelClicked);
+    cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onCancelClicked);
 }
 
 // widget controls
@@ -725,14 +725,14 @@ SelectAttributeDialog::SelectAttributeDialog(WindowManager& parWindowManager)
         getWidget(attribute,  std::string("Attribute").append(1, theIndex));
         attribute->setWindowManager(&parWindowManager);
         attribute->setAttributeId(ESM::Attribute::attributeIds[i]);
-        attribute->eventClicked = MyGUI::newDelegate(this, &SelectAttributeDialog::onAttributeClicked);
+        attribute->eventClicked += MyGUI::newDelegate(this, &SelectAttributeDialog::onAttributeClicked);
     }
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr cancelButton;
     getWidget(cancelButton, "CancelButton");
     cancelButton->setCaption(mWindowManager.getGameSettingString("sCancel", ""));
-    cancelButton->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectAttributeDialog::onCancelClicked);
+    cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectAttributeDialog::onCancelClicked);
 }
 
 // widget controls
@@ -813,7 +813,7 @@ SelectSkillDialog::SelectSkillDialog(WindowManager& parWindowManager)
         {
             skills[spec][i].widget->setWindowManager(&mWindowManager);
             skills[spec][i].widget->setSkillId(skills[spec][i].skillId);
-            skills[spec][i].widget->eventClicked = MyGUI::newDelegate(this, &SelectSkillDialog::onSkillClicked);
+            skills[spec][i].widget->eventClicked += MyGUI::newDelegate(this, &SelectSkillDialog::onSkillClicked);
         }
     }
 
@@ -821,7 +821,7 @@ SelectSkillDialog::SelectSkillDialog(WindowManager& parWindowManager)
     MyGUI::ButtonPtr cancelButton;
     getWidget(cancelButton, "CancelButton");
     cancelButton->setCaption(mWindowManager.getGameSettingString("sCancel", ""));
-    cancelButton->eventMouseButtonClick = MyGUI::newDelegate(this, &SelectSkillDialog::onCancelClicked);
+    cancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSkillDialog::onCancelClicked);
 }
 
 // widget controls
@@ -850,7 +850,7 @@ DescriptionDialog::DescriptionDialog(WindowManager& parWindowManager)
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &DescriptionDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &DescriptionDialog::onOkClicked);
     okButton->setCaption(mWindowManager.getGameSettingString("sInputMenu1", ""));
 
     // Make sure the edit box has focus

apps/openmw/mwgui/class.hpp

@@ -31,7 +31,7 @@ namespace MWGui
         int getChosenButton() const;
 
         // Events
-        typedef delegates::CDelegate1<int> EventHandle_Int;
+        typedef delegates::CMultiDelegate1<int> EventHandle_Int;
 
         /** Event : Button was clicked.\n
             signature : void method(MyGUI::WidgetPtr widget, int index)\n
@@ -43,11 +43,11 @@ namespace MWGui
 
     private:
 
-        void fitToText(MyGUI::StaticTextPtr widget);
+        void fitToText(MyGUI::TextBox* widget);
         void layoutVertically(MyGUI::WidgetPtr widget, int margin);
         int currentButton;
         MyGUI::WidgetPtr textBox;
-        MyGUI::StaticTextPtr text;
+        MyGUI::TextBox* text;
         MyGUI::WidgetPtr buttonBar;
         std::vector<MyGUI::ButtonPtr> buttons;
     };
@@ -78,7 +78,7 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Back button clicked.\n
             signature : void method()\n
@@ -90,8 +90,8 @@ namespace MWGui
         void onBackClicked(MyGUI::Widget* _sender);
 
     private:
-        MyGUI::StaticImagePtr classImage;
+        MyGUI::ImageBox* classImage;
-        MyGUI::StaticTextPtr  className;
+        MyGUI::TextBox*  className;
 
         std::string currentClassId;
     };
@@ -108,7 +108,7 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Back button clicked.\n
             signature : void method()\n
@@ -116,7 +116,7 @@ namespace MWGui
         EventHandle_Void eventBack;
 
     protected:
-        void onSelectClass(MyGUI::List* _sender, size_t _index);
+        void onSelectClass(MyGUI::ListBox* _sender, size_t _index);
 
         void onOkClicked(MyGUI::Widget* _sender);
         void onBackClicked(MyGUI::Widget* _sender);
@@ -125,9 +125,9 @@ namespace MWGui
         void updateClasses();
         void updateStats();
 
-        MyGUI::StaticImagePtr classImage;
+        MyGUI::ImageBox* classImage;
-        MyGUI::ListPtr        classList;
+        MyGUI::ListBox*        classList;
-        MyGUI::StaticTextPtr  specializationName;
+        MyGUI::TextBox*  specializationName;
         Widgets::MWAttributePtr favoriteAttribute[2];
         Widgets::MWSkillPtr   majorSkill[5];
         Widgets::MWSkillPtr   minorSkill[5];
@@ -143,7 +143,7 @@ namespace MWGui
         ESM::Class::Specialization getSpecializationId() const { return specializationId; }
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Cancel button clicked.\n
             signature : void method()\n
@@ -160,7 +160,7 @@ namespace MWGui
         void onCancelClicked(MyGUI::Widget* _sender);
 
     private:
-        MyGUI::WidgetPtr      specialization0, specialization1, specialization2;
+        MyGUI::TextBox      *specialization0, *specialization1, *specialization2;
 
         ESM::Class::Specialization specializationId;
     };
@@ -175,7 +175,7 @@ namespace MWGui
         void setAffectedWidget(Widgets::MWAttributePtr widget) { affectedWidget = widget; }
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Cancel button clicked.\n
             signature : void method()\n
@@ -207,7 +207,7 @@ namespace MWGui
         void setAffectedWidget(Widgets::MWSkillPtr widget) { affectedWidget = widget; }
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Cancel button clicked.\n
             signature : void method()\n
@@ -264,7 +264,7 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Back button clicked.\n
             signature : void method()\n
@@ -287,7 +287,7 @@ namespace MWGui
 
     private:
         MyGUI::EditPtr          editName;
-        MyGUI::WidgetPtr        specializationName;
+        MyGUI::TextBox*    specializationName;
         Widgets::MWAttributePtr favoriteAttribute0, favoriteAttribute1;
         Widgets::MWSkillPtr     majorSkill[5];
         Widgets::MWSkillPtr     minorSkill[5];

apps/openmw/mwgui/console.cpp

@@ -113,9 +113,9 @@ namespace MWGui
         getWidget(history, "list_History");
 
         // Set up the command line box
-        command->eventEditSelectAccept =
+        command->eventEditSelectAccept +=
             newDelegate(this, &Console::acceptCommand);
-        command->eventKeyButtonPressed =
+        command->eventKeyButtonPressed +=
             newDelegate(this, &Console::keyPress);
 
         // Set up the log window
@@ -139,6 +139,9 @@ namespace MWGui
     void Console::disable()
     {
         setVisible(false);
+        // Remove keyboard focus from the console input whenever the 
+        // console is turned off
+        MyGUI::InputManager::getInstance().setKeyFocusWidget(NULL);
     }
 
     void Console::setFont(const std::string &fntName)

apps/openmw/mwgui/dialogue.cpp

@@ -3,6 +3,8 @@
 #include "window_manager.hpp"
 #include "widgets.hpp"
 #include "components/esm_store/store.hpp"
+#include "../mwworld/environment.hpp"
+#include "../mwdialogue/dialoguemanager.hpp"
 
 #include <assert.h>
 #include <iostream>
@@ -14,107 +16,192 @@
 using namespace MWGui;
 using namespace Widgets;
 
-DialogueWindow::DialogueWindow(WindowManager& parWindowManager)
+/**
-  : WindowBase("openmw_dialogue_window_layout.xml", parWindowManager)
+*Copied from the internet.
+*/
+
+std::string lower_string(const std::string& str)
+{
+        std::string lowerCase;
+
+        std::transform (str.begin(), str.end(), std::back_inserter (lowerCase),
+            (int(*)(int)) std::tolower);
+
+        return lowerCase;
+}
+
+std::string::size_type find_str_ci(const std::string& str, const std::string& substr,size_t pos)
+{
+    return lower_string(str).find(lower_string(substr),pos);
+}
+
+
+DialogueWindow::DialogueWindow(WindowManager& parWindowManager,MWWorld::Environment& environment)
+    : WindowBase("openmw_dialogue_window_layout.xml", parWindowManager),
+    mEnvironment(environment)
 {
     // Centre dialog
     center();
 
     //WindowManager *wm = environment.mWindowManager;
     setText("NpcName", "Name of character");
-  
+
     //History view
     getWidget(history, "History");
     history->setOverflowToTheLeft(true);
-    history->getClient()->eventMouseButtonClick = MyGUI::newDelegate(this, &DialogueWindow::onHistoryClicked);
+    history->setMaxTextLength(1000000);
-   
+    Widget* eventbox;
-    //Topics list 
+
+    //An EditBox cannot receive mouse click events, so we use an
+    //invisible widget on top of the editbox to receive them
+    /// \todo scrolling the dialogue history with the mouse wheel doesn't work using this solution
+    getWidget(eventbox, "EventBox");
+    eventbox->eventMouseButtonClick += MyGUI::newDelegate(this, &DialogueWindow::onHistoryClicked);
+    
+    //Topics list
     getWidget(topicsList, "TopicsList");
     topicsList->setScrollVisible(true);
-    topicsList->eventListSelectAccept      = MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
+    //topicsList->eventListSelectAccept      += MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
-    topicsList->eventListMouseItemActivate = MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
+    topicsList->eventListMouseItemActivate += MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
-    topicsList->eventListChangePosition    = MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
+    //topicsList->eventListChangePosition    += MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
 
     MyGUI::ButtonPtr byeButton;
     getWidget(byeButton, "ByeButton");
-    byeButton->eventMouseButtonClick = MyGUI::newDelegate(this, &DialogueWindow::onByeClicked);
+    byeButton->eventMouseButtonClick += MyGUI::newDelegate(this, &DialogueWindow::onByeClicked);
 
-    updateOptions();
+    getWidget(pDispositionBar, "Disposition");
+    getWidget(pDispositionText,"DispositionText");
 }
 
 void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
 {
-    ISubWidgetText* t = history->getSubWidgetText();
+    ISubWidgetText* t = history->getClient()->getSubWidgetText();
     if(t == nullptr)
         return;
 
-    const IntPoint& lastPressed = InputManager::getInstance().getLastLeftPressed();
+    const IntPoint& lastPressed = InputManager::getInstance().getLastPressedPosition(MyGUI::MouseButton::Left);
 
     size_t cursorPosition = t->getCursorPosition(lastPressed);
-    if(history->getColorAtPos(cursorPosition) != "#FFFFFF")
+    MyGUI::UString color = history->getColorAtPos(cursorPosition);
+    if(color != "#B29154")
     {
         UString key = history->getColorTextAt(cursorPosition);
-        std::cout << "Clicked on key: " << key << std::endl;
+        if(color == "#686EBA") mEnvironment.mDialogueManager->keywordSelected(lower_string(key));
-        //eventTopicSelected(key);
+
+        if(color == "#572D21") mEnvironment.mDialogueManager->questionAnswered(key);
     }
 }
 
 void DialogueWindow::open()
 {
+    topicsList->removeAllItems();
+    pTopicsText.clear();
+    history->eraseText(0,history->getTextLength());
     updateOptions();
     setVisible(true);
 }
 
 void DialogueWindow::onByeClicked(MyGUI::Widget* _sender)
 {
-    eventBye();
+    mEnvironment.mDialogueManager->goodbyeSelected();
 }
 
-void DialogueWindow::onSelectTopic(MyGUI::List* _sender, size_t _index)
+void DialogueWindow::onSelectTopic(MyGUI::ListBox* _sender, size_t _index)
 {
     if (_index == MyGUI::ITEM_NONE)
         return;
-
+    std::string topic =  _sender->getItemNameAt(_index);
-    //const std::string* theTopic  = topicsList->getItemDataAt<std::string>(_index);
+    mEnvironment.mDialogueManager->keywordSelected(lower_string(topic));
-    //std::cout << "Selected: "<< theTopic << std::endl;
-    //eventTopicSelected(key);
 }
 
+void DialogueWindow::startDialogue(std::string npcName)
+{
+    setText("NpcName", npcName);
+}
+
+void DialogueWindow::setKeywords(std::list<std::string> keyWords)
+{
+    topicsList->removeAllItems();
+    for(std::list<std::string>::iterator it = keyWords.begin(); it != keyWords.end(); it++)
+    {
+        topicsList->addItem(*it);
+    }
+}
+
+void DialogueWindow::removeKeyword(std::string keyWord)
+{
+    if(topicsList->findItemIndexWith(keyWord) != MyGUI::ITEM_NONE)
+    {
+        topicsList->removeItemAt(topicsList->findItemIndexWith(keyWord));
+        pTopicsText.erase(keyWord);
+    }
+}
+
+void addColorInString(std::string& str, const std::string& keyword,std::string color1, std::string color2)
+{
+    size_t pos = 0;
+    while((pos = find_str_ci(str,keyword, pos)) != std::string::npos)
+    {
+        if(pos==0)
+        {
+            str.insert(pos,color1);
+            pos += color1.length();
+            pos += keyword.length();
+            str.insert(pos,color2);
+            pos+= color2.length();
+        }
+        else
+        {
+            if(str.substr(pos -1,1) == " ")
+            {
+                str.insert(pos,color1);
+                pos += color1.length();
+                pos += keyword.length();
+                str.insert(pos,color2);
+                pos+= color2.length();
+            }
+            else
+            {
+                pos += keyword.length();
+            }
+        }
+    }
+}
+
+std::string DialogueWindow::parseText(std::string text)
+{
+    for(unsigned int i = 0;i<topicsList->getItemCount();i++)
+    {
+        std::string keyWord = topicsList->getItemNameAt(i);
+        addColorInString(text,keyWord,"#686EBA","#B29154");
+    }
+    return text;
+}
+
+void DialogueWindow::addText(std::string text)
+{
+    history->addDialogText("#B29154"+parseText(text)+"#B29154");
+}
+
+void DialogueWindow::addTitle(std::string text)
+{
+    history->addDialogHeading(text);
+}
+
+void DialogueWindow::askQuestion(std::string question)
+{
+    history->addDialogText("#572D21"+question+"#B29154"+" ");
+}
 
 void DialogueWindow::updateOptions()
 {
-    //FIXME Add this properly
-    history->addDialogText("Through the translucent surface of the orb, you see shifting images of distant locations...");
-    for(int z = 0; z < 10; z++)
-    {
-        history->addDialogHeading("Fort Frostmoth");
-        history->addDialogText("The image in the orb flickers, and you see.... The cold courtyard of #FF0000Fort Frostmoth#FFFFFF, battered bu werewolf attack, but still standing, still projecting Imperial might even to this distant and cold corner of the world.");
-    }
-
     //Clear the list of topics
     topicsList->removeAllItems();
-    int i = 0;
+    pTopicsText.clear();
-    topicsList->addItem("Ald'ruhn", i++);
+    history->eraseText(0,history->getTextLength());
-    topicsList->addItem("Balmora", i++);
-    topicsList->addItem("Sadrith Mora", i++);
-    topicsList->addItem("Vivec", i++);
-    topicsList->addItem("Ald Velothi", i++);
-    topicsList->addItem("Caldera", i++);
-    topicsList->addItem("Dagon Fel ", i++);
-    topicsList->addItem("Gnaar Mok", i++);
-    topicsList->addItem("Gnisis", i++);
-    topicsList->addItem("Hla Oad", i++);
-    topicsList->addItem("Khuul", i++);
-    topicsList->addItem("Maar Gan", i++);
-    topicsList->addItem("Molag Mar", i++);
-    topicsList->addItem("Pelagiad", i++);
-    topicsList->addItem("Seyda Neen", i++);
-    topicsList->addItem("Suran", i++);
-    topicsList->addItem("Tel Aruhn", i++);
-    topicsList->addItem("Tel Branora", i++);
-    topicsList->addItem("Tel Fyr", i++);
-    topicsList->addItem("Tel Mora", i++);
-    topicsList->addItem("Tel Vos", i++);
-    topicsList->addItem("Vos", i++);
-}
 
+    pDispositionBar->setProgressRange(100);
+    pDispositionBar->setProgressPosition(40);
+    pDispositionText->eraseText(0,pDispositionText->getTextLength());
+    pDispositionText->addText("#B29154"+std::string("40/100")+"#B29154");
+}

apps/openmw/mwgui/dialogue.hpp

@@ -9,6 +9,11 @@ namespace MWGui
     class WindowManager;
 }
 
+namespace MWWorld
+{
+    class Environment;
+}
+
 /*
   This file contains the dialouge window
   Layout is defined by resources/mygui/openmw_dialogue_window_layout.xml.
@@ -16,35 +21,52 @@ namespace MWGui
 
 namespace MWGui
 {
-    class DialogeHistory;
+    class DialogueHistory;
 
     using namespace MyGUI;
 
     class DialogueWindow: public WindowBase
     {
     public:
-        DialogueWindow(WindowManager& parWindowManager);
+        DialogueWindow(WindowManager& parWindowManager,MWWorld::Environment& environment);
 
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Dialog finished, OK button clicked.\n
             signature : void method()\n
         */
         EventHandle_Void eventBye;
 
+        void startDialogue(std::string npcName);
+        void stopDialogue();
+        void setKeywords(std::list<std::string> keyWord);
+        void removeKeyword(std::string keyWord);
+        void addText(std::string text);
+        void addTitle(std::string text);
+        void askQuestion(std::string question);
+
     protected:
-        void onSelectTopic(MyGUI::List* _sender, size_t _index);
+        void onSelectTopic(MyGUI::ListBox* _sender, size_t _index);
         void onByeClicked(MyGUI::Widget* _sender);
         void onHistoryClicked(MyGUI::Widget* _sender);
 
     private:
         void updateOptions();
+        /**
+        *Helper function that add topic keyword in blue in a text.
+        */
+        std::string parseText(std::string text);
 
-        DialogeHistory*     history;
+        DialogueHistory*     history;
-        MyGUI::ListPtr      topicsList;
+        MyGUI::ListBox*      topicsList;
+        MyGUI::ProgressPtr pDispositionBar;
+        MyGUI::EditPtr pDispositionText;
+        std::map<std::string,std::string> pTopicsText;// this map links keyword and "real" text.
+
+        MWWorld::Environment& mEnvironment;
     };
 }
 #endif

apps/openmw/mwgui/dialogue_history.cpp

@@ -13,10 +13,10 @@
 using namespace MWGui;
 using namespace Widgets;
 
-UString DialogeHistory::getColorAtPos(size_t _pos)
+UString DialogueHistory::getColorAtPos(size_t _pos)
 {
-    UString colour = TextIterator::convertTagColour(mText->getTextColour());
+    UString colour = TextIterator::convertTagColour(getTextColour());
-    TextIterator iterator(mText->getCaption());
+    TextIterator iterator(getCaption());
     while(iterator.moveNext())
     {
         size_t pos = iterator.getPosition();
@@ -29,12 +29,12 @@ UString DialogeHistory::getColorAtPos(size_t _pos)
     return colour;
 }
 
-UString DialogeHistory::getColorTextAt(size_t _pos)
+UString DialogueHistory::getColorTextAt(size_t _pos)
 {
     bool breakOnNext = false;
-    UString colour = TextIterator::convertTagColour(mText->getTextColour());
+    UString colour = TextIterator::convertTagColour(getTextColour());
     UString colour2 = colour;
-    TextIterator iterator(mText->getCaption());
+    TextIterator iterator(getCaption());
     TextIterator col_start = iterator;
     while(iterator.moveNext())
     {
@@ -59,15 +59,15 @@ UString DialogeHistory::getColorTextAt(size_t _pos)
     return "";
 }
 
-void DialogeHistory::addDialogHeading(const UString& parText)
+void DialogueHistory::addDialogHeading(const UString& parText)
 {
-    UString head("\n#00FF00");
+    UString head("\n#D8C09A");
     head.append(parText);
-    head.append("#FFFFFF\n");
+    head.append("#B29154\n");
     addText(head);
 }
 
-void DialogeHistory::addDialogText(const UString& parText)
+void DialogueHistory::addDialogText(const UString& parText)
 {
     addText(parText);
     addText("\n");

apps/openmw/mwgui/dialogue_history.hpp

@@ -5,9 +5,9 @@
 namespace MWGui
 {
     using namespace MyGUI;
-    class DialogeHistory : public MyGUI::Edit
+    class DialogueHistory : public MyGUI::EditBox
     {
-        MYGUI_RTTI_DERIVED( DialogeHistory )
+        MYGUI_RTTI_DERIVED( DialogueHistory )
         public:
             Widget* getClient() { return mClient; }
             UString getColorAtPos(size_t _pos);

apps/openmw/mwgui/journalwindow.cpp

@@ -89,9 +89,9 @@ MWGui::JournalWindow::JournalWindow (WindowManager& parWindowManager)
     getWidget(mLeftTextWidget, "LeftText");
     getWidget(mRightTextWidget, "RightText");
     getWidget(mPrevBtn, "PrevPageBTN");
-    mPrevBtn->eventMouseButtonClick = MyGUI::newDelegate(this,&MWGui::JournalWindow::notifyPrevPage);
+    mPrevBtn->eventMouseButtonClick += MyGUI::newDelegate(this,&MWGui::JournalWindow::notifyPrevPage);
     getWidget(mNextBtn, "NextPageBTN");
-    mNextBtn->eventMouseButtonClick = MyGUI::newDelegate(this,&MWGui::JournalWindow::notifyNextPage);
+    mNextBtn->eventMouseButtonClick += MyGUI::newDelegate(this,&MWGui::JournalWindow::notifyNextPage);
     //MyGUI::ItemBox* list = new MyGUI::ItemBox();
     //list->addItem("qaq","aqzazaz");
     //mScrollerWidget->addChildItem(list);
@@ -111,7 +111,7 @@ MWGui::JournalWindow::JournalWindow (WindowManager& parWindowManager)
     //displayLeftText(list.front());
 
     MyGUI::WindowPtr t = static_cast<MyGUI::WindowPtr>(mMainWidget);
-    t->eventWindowChangeCoord = MyGUI::newDelegate(this, &JournalWindow::onWindowResize);
+    t->eventWindowChangeCoord += MyGUI::newDelegate(this, &JournalWindow::onWindowResize);
 }
 
 void MWGui::JournalWindow::open()

apps/openmw/mwgui/journalwindow.hpp

@@ -41,7 +41,7 @@ namespace MWGui
             static const int lineHeight;
 
             MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
-            MyGUI::VScrollPtr skillScrollerWidget;
+            MyGUI::ScrollBar* skillScrollerWidget;
             int lastPos, clientHeight;
             MyGUI::EditPtr mLeftTextWidget;
             MyGUI::EditPtr mRightTextWidget;
@@ -54,4 +54,4 @@ namespace MWGui
 
 }
 
-#endif
+#endif

apps/openmw/mwgui/layouts.hpp

@@ -45,18 +45,18 @@ namespace MWGui
     void setBatchCount(size_t count);
 
     MyGUI::ProgressPtr health, magicka, stamina;
-    MyGUI::StaticImagePtr weapImage, spellImage;
+    MyGUI::ImageBox *weapImage, *spellImage;
     MyGUI::ProgressPtr weapStatus, spellStatus;
     MyGUI::WidgetPtr effectBox;
-    MyGUI::StaticImagePtr effect1;
+    MyGUI::ImageBox* effect1;
-    MyGUI::StaticImagePtr minimap;
+    MyGUI::ImageBox* minimap;
-    MyGUI::StaticImagePtr compass;
+    MyGUI::ImageBox* compass;
-    MyGUI::StaticImagePtr crosshair;
+    MyGUI::ImageBox* crosshair;
 
     MyGUI::WidgetPtr fpsbox;
-    MyGUI::StaticTextPtr fpscounter;
+    MyGUI::TextBox* fpscounter;
-    MyGUI::StaticTextPtr trianglecounter;
+    MyGUI::TextBox* trianglecounter;
-    MyGUI::StaticTextPtr batchcounter;
+    MyGUI::TextBox* batchcounter;
   };
 
   class MapWindow : public OEngine::GUI::Layout
@@ -75,7 +75,7 @@ namespace MWGui
 
     void setCellName(const std::string& cellName)
     {
-      mMainWidget->setCaption(cellName);
+      static_cast<MyGUI::Window*>(mMainWidget)->setCaption(cellName);
     }
   };
 
@@ -127,7 +127,7 @@ namespace MWGui
       getWidget(avatar, "Avatar");
 
       // Adjust armor rating text to bottom of avatar widget
-      MyGUI::StaticTextPtr armor_rating;
+      MyGUI::TextBox* armor_rating;
       getWidget(armor_rating, "ArmorRating");
       armor_rating->setCaption("Armor: 11");
       MyGUI::IntCoord coord = armor_rating->getCoord();
@@ -165,7 +165,7 @@ namespace MWGui
           last_x += coord.width + margin;
           button_pt->setCoord(coord);
 
-          button_pt->eventMouseButtonClick = MyGUI::newDelegate(this, &InventoryWindow::onCategorySelected);
+          button_pt->eventMouseButtonClick += MyGUI::newDelegate(this, &InventoryWindow::onCategorySelected);
       }
     }
 

apps/openmw/mwgui/messagebox.cpp

@@ -19,7 +19,7 @@ void MessageBoxManager::onFrame (float frameDuration)
         if(it->current >= it->max)
         {
             it->messageBox->mMarkedToDelete = true;
-            
+
             if(*mMessageBoxes.begin() == it->messageBox) // if this box is the last one
             {
                 // collect all with mMarkedToDelete and delete them.
@@ -47,7 +47,7 @@ void MessageBoxManager::onFrame (float frameDuration)
             it++;
         }
     }
-    
+
     if(mInterMessageBoxe != NULL && mInterMessageBoxe->mMarkedToDelete) {
         delete mInterMessageBoxe;
         mInterMessageBoxe = NULL;
@@ -57,20 +57,18 @@ void MessageBoxManager::onFrame (float frameDuration)
 
 void MessageBoxManager::createMessageBox (const std::string& message)
 {
-    std::cout << "MessageBox: " << message << std::endl;
-    
     MessageBox *box = new MessageBox(*this, message);
-    
+
     removeMessageBox(message.length()*mMessageBoxSpeed, box);
-    
+
     mMessageBoxes.push_back(box);
     std::vector<MessageBox*>::iterator it;
-    
+
     if(mMessageBoxes.size() > 3) {
         delete *mMessageBoxes.begin();
         mMessageBoxes.erase(mMessageBoxes.begin());
     }
-    
+
     int height = 0;
     for(it = mMessageBoxes.begin(); it != mMessageBoxes.end(); ++it)
     {
@@ -88,9 +86,9 @@ bool MessageBoxManager::createInteractiveMessageBox (const std::string& message,
     std::cout << "interactive MessageBox: " << message << " - ";
     std::copy (buttons.begin(), buttons.end(), std::ostream_iterator<std::string> (std::cout, ", "));
     std::cout << std::endl;
-    
+
     mInterMessageBoxe = new InteractiveMessageBox(*this, message, buttons);
-    
+
     return true;
 }
 
@@ -105,7 +103,7 @@ void MessageBoxManager::removeMessageBox (float time, MessageBox *msgbox)
     timer.current = 0;
     timer.max = time;
     timer.messageBox = msgbox;
-    
+
     mTimers.insert(mTimers.end(), timer);
 }
 
@@ -152,25 +150,26 @@ MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::strin
     mBottomPadding = 20;
     mNextBoxPadding = 20;
     mMarkedToDelete = false;
-    
+
     getWidget(mMessageWidget, "message");
-    
+
     mMessageWidget->setOverflowToTheLeft(true);
     mMessageWidget->addText(cMessage);
-    
+
     MyGUI::IntSize size;
     size.width = mFixedWidth;
     size.height = 100; // dummy
-    
+
     MyGUI::IntCoord coord;
     coord.left = 10; // dummy
     coord.top = 10; // dummy
 
     mMessageWidget->setSize(size);
-    
+
-    MyGUI::IntSize textSize = mMessageWidget->_getTextSize();
+    MyGUI::IntSize textSize = mMessageWidget->getTextSize();
+
     size.height = mHeight = textSize.height + 20; // this is the padding between the text and the box
-    
+
     mMainWidget->setSize(size);
     size.width -= 15; // this is to center the text (see messagebox_layout.xml, Widget type="Edit" position="-2 -3 0 0")
     mMessageWidget->setSize(size);
@@ -178,15 +177,15 @@ MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::strin
 
 void MessageBox::update (int height)
 {
-    MyGUI::IntSize gameWindowSize = mMessageBoxManager.mWindowManager->getGui()->getViewSize();
+    MyGUI::IntSize gameWindowSize = MyGUI::RenderManager::getInstance().getViewSize();
     MyGUI::IntCoord coord;
     coord.left = (gameWindowSize.width - mFixedWidth)/2;
     coord.top = (gameWindowSize.height - mHeight - height - mBottomPadding);
-    
+
     MyGUI::IntSize size;
     size.width = mFixedWidth;
     size.height = mHeight;
-    
+
     mMainWidget->setCoord(coord);
     mMainWidget->setSize(size);
     mMainWidget->setVisible(true);
@@ -211,26 +210,26 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
     int buttonTopPadding = 5; // ^-- if vertical
     int buttonPadding = 5; // padding between button label and button itself
     int buttonMainPadding = 10; // padding between buttons and bottom of the main widget
-    
+
     mMarkedToDelete = false;
-    
+
-    
+
     getWidget(mMessageWidget, "message");
     getWidget(mButtonsWidget, "buttons");
-    
+
     mMessageWidget->setOverflowToTheLeft(true);
     mMessageWidget->addText(message);
-    
+
-    MyGUI::IntSize textSize = mMessageWidget->_getTextSize();
+    MyGUI::IntSize textSize = mMessageWidget->getTextSize();
-    
+
-    MyGUI::IntSize gameWindowSize = mMessageBoxManager.mWindowManager->getGui()->getViewSize();
+    MyGUI::IntSize gameWindowSize = MyGUI::RenderManager::getInstance().getViewSize();
-    
+
     int biggestButtonWidth = 0;
     int buttonWidth = 0;
     int buttonsWidth = 0;
     int buttonHeight = 0;
     MyGUI::IntCoord dummyCoord(0, 0, 0, 0);
-    
+
     std::vector<std::string>::const_iterator it;
     for(it = buttons.begin(); it != buttons.end(); ++it)
     {
@@ -240,28 +239,28 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
             dummyCoord,
             MyGUI::Align::Default);
         button->setCaption(*it);
-        
+
-        button->eventMouseButtonClick = MyGUI::newDelegate(this, &InteractiveMessageBox::mousePressed); 
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &InteractiveMessageBox::mousePressed);
-        
+
         mButtons.push_back(button);
-        
+
-        buttonWidth = button->_getTextSize().width + 2*buttonPadding + buttonLeftPadding;
+        buttonWidth = button->getTextSize().width + 2*buttonPadding + buttonLeftPadding;
         buttonsWidth += buttonWidth;
-        buttonHeight = button->_getTextSize().height + 2*buttonPadding + buttonTopPadding;
+        buttonHeight = button->getTextSize().height + 2*buttonPadding + buttonTopPadding;
-        
+
         if(buttonWidth > biggestButtonWidth)
         {
             biggestButtonWidth = buttonWidth;
         }
     }
     buttonsWidth += buttonLeftPadding;
-    
+
     MyGUI::IntSize mainWidgetSize;
     if(buttonsWidth < fixedWidth)
     {
         // on one line
         std::cout << "on one line" << std::endl;
-        
+
         if(textSize.width + 2*textPadding < buttonsWidth)
         {
             std::cout << "width = buttonsWidth" << std::endl;
@@ -272,48 +271,48 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
             mainWidgetSize.width = textSize.width + 3*textPadding;
         }
         mainWidgetSize.height = textSize.height + textButtonPadding + buttonHeight + buttonMainPadding;
-        
+
         MyGUI::IntCoord absCoord;
         absCoord.left = (gameWindowSize.width - mainWidgetSize.width)/2;
         absCoord.top = (gameWindowSize.height - mainWidgetSize.height)/2;
-        
+
         std::cout << "width " << mainWidgetSize.width << " height " << mainWidgetSize.height << std::endl;
         std::cout << "left " << absCoord.left << " top " << absCoord.top << std::endl;
-        
+
         mMainWidget->setCoord(absCoord);
         mMainWidget->setSize(mainWidgetSize);
-        
+
-        
+
         MyGUI::IntCoord messageWidgetCoord;
         messageWidgetCoord.left = (mainWidgetSize.width - textSize.width)/2;
         messageWidgetCoord.top = textPadding;
         mMessageWidget->setCoord(messageWidgetCoord);
-        
+
         mMessageWidget->setSize(textSize);
-        
+
         MyGUI::IntCoord buttonCord;
         MyGUI::IntSize buttonSize(0, buttonHeight);
         int left = (mainWidgetSize.width - buttonsWidth)/2 + buttonPadding;
-        
+
         std::vector<MyGUI::ButtonPtr>::const_iterator button;
         for(button = mButtons.begin(); button != mButtons.end(); ++button)
         {
             buttonCord.left = left;
             buttonCord.top = textSize.height + textButtonPadding;
-            
+
-            buttonSize.width = (*button)->_getTextSize().width + 2*buttonPadding;
+            buttonSize.width = (*button)->getTextSize().width + 2*buttonPadding;
-            buttonSize.height = (*button)->_getTextSize().height + 2*buttonPadding;
+            buttonSize.height = (*button)->getTextSize().height + 2*buttonPadding;
-            
+
             (*button)->setCoord(buttonCord);
             (*button)->setSize(buttonSize);
-            
+
             left += buttonSize.width + buttonLeftPadding;
         }
     }
     else
     {
         // among each other
-        
+
         if(biggestButtonWidth > textSize.width) {
             mainWidgetSize.width = biggestButtonWidth + buttonTopPadding;
         }
@@ -321,46 +320,46 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
             mainWidgetSize.width = textSize.width + 3*textPadding;
         }
         mainWidgetSize.height = textSize.height + 2*textPadding + textButtonPadding + buttonHeight * buttons.size() + buttonMainPadding;
-        
+
         std::cout << "biggestButtonWidth " << biggestButtonWidth << " textSize.width " << textSize.width << std::endl;
         std::cout << "width " << mainWidgetSize.width << " height " << mainWidgetSize.height << std::endl;
         mMainWidget->setSize(mainWidgetSize);
-        
+
         MyGUI::IntCoord absCoord;
         absCoord.left = (gameWindowSize.width - mainWidgetSize.width)/2;
         absCoord.top = (gameWindowSize.height - mainWidgetSize.height)/2;
-        
+
         mMainWidget->setCoord(absCoord);
         mMainWidget->setSize(mainWidgetSize);
-        
+
-        
+
         MyGUI::IntCoord messageWidgetCoord;
         messageWidgetCoord.left = (mainWidgetSize.width - textSize.width)/2;
         messageWidgetCoord.top = textPadding;
         mMessageWidget->setCoord(messageWidgetCoord);
-        
+
         mMessageWidget->setSize(textSize);
-        
+
         MyGUI::IntCoord buttonCord;
         MyGUI::IntSize buttonSize(0, buttonHeight);
-        
+
         int top = textButtonPadding + buttonTopPadding + textSize.height;
-        
+
         std::vector<MyGUI::ButtonPtr>::const_iterator button;
         for(button = mButtons.begin(); button != mButtons.end(); ++button)
         {
-            buttonSize.width = (*button)->_getTextSize().width + buttonPadding*2;
+            buttonSize.width = (*button)->getTextSize().width + buttonPadding*2;
-            buttonSize.height = (*button)->_getTextSize().height + buttonPadding*2;
+            buttonSize.height = (*button)->getTextSize().height + buttonPadding*2;
-            
+
             buttonCord.top = top;
             buttonCord.left = (mainWidgetSize.width - buttonSize.width)/2 - 5; // FIXME: -5 is not so nice :/
-            
+
             (*button)->setCoord(buttonCord);
             (*button)->setSize(buttonSize);
-            
+
             top += buttonSize.height + 2*buttonTopPadding;
         }
-        
+
     }
 }
 
@@ -387,8 +386,3 @@ int InteractiveMessageBox::readPressedButton ()
     mButtonPressed = -1;
     return pressed;
 }
-
-
-
-
-

apps/openmw/mwgui/race.cpp

@@ -34,7 +34,7 @@ RaceDialog::RaceDialog(WindowManager& parWindowManager)
     headRotate->setScrollRange(50);
     headRotate->setScrollPosition(20);
     headRotate->setScrollViewPage(10);
-    headRotate->eventScrollChangePosition = MyGUI::newDelegate(this, &RaceDialog::onHeadRotate);
+    headRotate->eventScrollChangePosition += MyGUI::newDelegate(this, &RaceDialog::onHeadRotate);
 
     // Set up next/previous buttons
     MyGUI::ButtonPtr prevButton, nextButton;
@@ -42,27 +42,27 @@ RaceDialog::RaceDialog(WindowManager& parWindowManager)
     setText("GenderChoiceT", mWindowManager.getGameSettingString("sRaceMenu2", "Change Sex"));
     getWidget(prevButton, "PrevGenderButton");
     getWidget(nextButton, "NextGenderButton");
-    prevButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousGender);
+    prevButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousGender);
-    nextButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectNextGender);
+    nextButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectNextGender);
 
     setText("FaceChoiceT", mWindowManager.getGameSettingString("sRaceMenu3", "Change Face"));
     getWidget(prevButton, "PrevFaceButton");
     getWidget(nextButton, "NextFaceButton");
-    prevButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousFace);
+    prevButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousFace);
-    nextButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectNextFace);
+    nextButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectNextFace);
 
     setText("HairChoiceT", mWindowManager.getGameSettingString("sRaceMenu3", "Change Hair"));
     getWidget(prevButton, "PrevHairButton");
     getWidget(nextButton, "NextHairButton");
-    prevButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousHair);
+    prevButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectPreviousHair);
-    nextButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onSelectNextHair);
+    nextButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectNextHair);
 
     setText("RaceT", mWindowManager.getGameSettingString("sRaceMenu4", "Race"));
     getWidget(raceList, "RaceList");
     raceList->setScrollVisible(true);
-    raceList->eventListSelectAccept = MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
+    raceList->eventListSelectAccept += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
-    raceList->eventListMouseItemActivate = MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
+    raceList->eventListMouseItemActivate += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
-    raceList->eventListChangePosition = MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
+    raceList->eventListChangePosition += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
 
     setText("SkillsT", mWindowManager.getGameSettingString("sBonusSkillTitle", "Skill Bonus"));
     getWidget(skillList, "SkillList");
@@ -72,11 +72,11 @@ RaceDialog::RaceDialog(WindowManager& parWindowManager)
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &RaceDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onOkClicked);
 
     updateRaces();
     updateSkills();
@@ -157,7 +157,7 @@ void RaceDialog::onBackClicked(MyGUI::Widget* _sender)
     eventBack();
 }
 
-void RaceDialog::onHeadRotate(MyGUI::VScroll*, size_t _position)
+void RaceDialog::onHeadRotate(MyGUI::ScrollBar*, size_t _position)
 {
     // TODO: Rotate head
 }
@@ -192,7 +192,7 @@ void RaceDialog::onSelectNextHair(MyGUI::Widget*)
     hairIndex = wrap(hairIndex - 1, hairCount);
 }
 
-void RaceDialog::onSelectRace(MyGUI::List* _sender, size_t _index)
+void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
 {
     if (_index == MyGUI::ITEM_NONE)
         return;

apps/openmw/mwgui/race.hpp

@@ -46,7 +46,7 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
 
         /** Event : Back button clicked.\n
             signature : void method()\n
@@ -54,7 +54,7 @@ namespace MWGui
         EventHandle_Void eventBack;
 
     protected:
-        void onHeadRotate(MyGUI::VScroll* _sender, size_t _position);
+        void onHeadRotate(MyGUI::ScrollBar* _sender, size_t _position);
 
         void onSelectPreviousGender(MyGUI::Widget* _sender);
         void onSelectNextGender(MyGUI::Widget* _sender);
@@ -65,7 +65,7 @@ namespace MWGui
         void onSelectPreviousHair(MyGUI::Widget* _sender);
         void onSelectNextHair(MyGUI::Widget* _sender);
 
-        void onSelectRace(MyGUI::List* _sender, size_t _index);
+        void onSelectRace(MyGUI::ListBox* _sender, size_t _index);
 
         void onOkClicked(MyGUI::Widget* _sender);
         void onBackClicked(MyGUI::Widget* _sender);
@@ -76,8 +76,8 @@ namespace MWGui
         void updateSpellPowers();
 
         MyGUI::CanvasPtr  appearanceBox;
-        MyGUI::ListPtr    raceList;
+        MyGUI::ListBox*    raceList;
-        MyGUI::HScrollPtr headRotate;
+        MyGUI::ScrollBar* headRotate;
 
         MyGUI::WidgetPtr skillList;
         std::vector<MyGUI::WidgetPtr> skillItems;

apps/openmw/mwgui/review.cpp

@@ -28,22 +28,22 @@ ReviewDialog::ReviewDialog(WindowManager& parWindowManager)
     getWidget(nameWidget, "NameText");
     getWidget(button, "NameButton");
     button->setCaption(mWindowManager.getGameSettingString("sName", ""));
-    button->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onNameClicked);;
+    button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onNameClicked);;
 
     getWidget(raceWidget, "RaceText");
     getWidget(button, "RaceButton");
     button->setCaption(mWindowManager.getGameSettingString("sRace", ""));
-    button->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onRaceClicked);;
+    button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onRaceClicked);;
 
     getWidget(classWidget, "ClassText");
     getWidget(button, "ClassButton");
     button->setCaption(mWindowManager.getGameSettingString("sClass", ""));
-    button->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onClassClicked);;
+    button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onClassClicked);;
 
     getWidget(birthSignWidget, "SignText");
     getWidget(button, "SignButton");
     button->setCaption(mWindowManager.getGameSettingString("sBirthSign", ""));
-    button->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onBirthSignClicked);;
+    button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onBirthSignClicked);;
 
     // Setup dynamic stats
     getWidget(health, "Health");
@@ -75,25 +75,25 @@ ReviewDialog::ReviewDialog(WindowManager& parWindowManager)
     getWidget(skillClientWidget, "SkillClient");
     getWidget(skillScrollerWidget, "SkillScroller");
 
-    skillScrollerWidget->eventScrollChangePosition = MyGUI::newDelegate(this, &ReviewDialog::onScrollChangePosition);
+    skillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &ReviewDialog::onScrollChangePosition);
     updateScroller();
 
     for (int i = 0; i < ESM::Skill::Length; ++i)
     {
         skillValues.insert(std::make_pair(i, MWMechanics::Stat<float>()));
-        skillWidgetMap.insert(std::make_pair(i, static_cast<MyGUI::StaticText*> (0)));
+        skillWidgetMap.insert(std::make_pair(i, static_cast<MyGUI::TextBox*> (0)));
     }
 
-    static_cast<MyGUI::WindowPtr>(mMainWidget)->eventWindowChangeCoord = MyGUI::newDelegate(this, &ReviewDialog::onWindowResize);
+    static_cast<MyGUI::WindowPtr>(mMainWidget)->eventWindowChangeCoord += MyGUI::newDelegate(this, &ReviewDialog::onWindowResize);
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr backButton;
     getWidget(backButton, "BackButton");
-    backButton->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onBackClicked);
+    backButton->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onBackClicked);
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &ReviewDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onOkClicked);
 }
 
 void ReviewDialog::open()
@@ -102,7 +102,7 @@ void ReviewDialog::open()
     setVisible(true);
 }
 
-void ReviewDialog::onScrollChangePosition(MyGUI::VScrollPtr scroller, size_t pos)
+void ReviewDialog::onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos)
 {
     int diff = lastPos - pos;
     // Adjust position of all widget according to difference
@@ -176,7 +176,7 @@ void ReviewDialog::setAttribute(ESM::Attribute::AttributeID attributeId, const M
 void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanics::Stat<float>& value)
 {
     skillValues[skillId] = value;
-    MyGUI::StaticTextPtr widget = skillWidgetMap[skillId];
+    MyGUI::TextBox* widget = skillWidgetMap[skillId];
     if (widget)
     {
         float modified = value.getModified(), base = value.getBase();
@@ -210,7 +210,7 @@ void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vec
     }
 }
 
-void ReviewDialog::setStyledText(MyGUI::StaticTextPtr widget, ColorStyle style, const std::string &value)
+void ReviewDialog::setStyledText(MyGUI::TextBox* widget, ColorStyle style, const std::string &value)
 {
     widget->setCaption(value);
     if (style == CS_Super)
@@ -223,7 +223,7 @@ void ReviewDialog::setStyledText(MyGUI::StaticTextPtr widget, ColorStyle style,
 
 void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticImagePtr separator = skillClientWidget->createWidget<MyGUI::StaticImage>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
+    MyGUI::ImageBox* separator = skillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
     skillWidgets.push_back(separator);
 
     coord1.top += separator->getHeight();
@@ -232,7 +232,7 @@ void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2
 
 void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr groupWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
+    MyGUI::TextBox* groupWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
     groupWidget->setCaption(label);
     skillWidgets.push_back(groupWidget);
 
@@ -240,14 +240,15 @@ void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, M
     coord2.top += lineHeight;
 }
 
-MyGUI::StaticTextPtr ReviewDialog::addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
+MyGUI::TextBox* ReviewDialog::addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr skillNameWidget, skillValueWidget;
+    MyGUI::TextBox* skillNameWidget;
+    MyGUI::TextBox* skillValueWidget;
 
-    skillNameWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandText", coord1, MyGUI::Align::Default);
+    skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Default);
     skillNameWidget->setCaption(text);
 
-    skillValueWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandTextRight", coord2, MyGUI::Align::Default);
+    skillValueWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Default);
     setStyledText(skillValueWidget, style, value);
 
     skillWidgets.push_back(skillNameWidget);
@@ -261,9 +262,9 @@ MyGUI::StaticTextPtr ReviewDialog::addValueItem(const std::string text, const st
 
 void ReviewDialog::addItem(const std::string text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr skillNameWidget;
+    MyGUI::TextBox* skillNameWidget;
 
-    skillNameWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
+    skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
     skillNameWidget->setCaption(text);
 
     skillWidgets.push_back(skillNameWidget);
@@ -299,7 +300,7 @@ void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId
             style = CS_Super;
         else if (modified < base)
             style = CS_Sub;
-        MyGUI::StaticTextPtr widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), style, coord1, coord2);
+        MyGUI::TextBox* widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), style, coord1, coord2);
         skillWidgetMap[skillId] = widget;
     }
 }

apps/openmw/mwgui/review.hpp

@@ -49,8 +49,8 @@ namespace MWGui
         void open();
 
         // Events
-        typedef delegates::CDelegate0 EventHandle_Void;
+        typedef delegates::CMultiDelegate0 EventHandle_Void;
-        typedef delegates::CDelegate1<int> EventHandle_Int;
+        typedef delegates::CMultiDelegate1<int> EventHandle_Int;
 
         /** Event : Back button clicked.\n
         signature : void method()\n
@@ -75,23 +75,23 @@ namespace MWGui
             CS_Normal,
             CS_Super
         };
-        void setStyledText(MyGUI::StaticTextPtr widget, ColorStyle style, const std::string &value);
+        void setStyledText(MyGUI::TextBox* widget, ColorStyle style, const std::string &value);
         void addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
         void addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
         void addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
-        MyGUI::StaticTextPtr addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
+        MyGUI::TextBox* addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
         void addItem(const std::string text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
         void updateScroller();
         void updateSkillArea();
 
-        void onScrollChangePosition(MyGUI::VScrollPtr scroller, size_t pos);
+        void onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos);
         void onWindowResize(MyGUI::Window* window);
 
         static const int lineHeight;
 
-        MyGUI::StaticTextPtr nameWidget, raceWidget, classWidget, birthSignWidget;
+        MyGUI::TextBox *nameWidget, *raceWidget, *classWidget, *birthSignWidget;
         MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
-        MyGUI::VScrollPtr skillScrollerWidget;
+        MyGUI::ScrollBar* skillScrollerWidget;
         int lastPos, clientHeight;
 
         Widgets::MWDynamicStatPtr health, magicka, fatigue;
@@ -100,7 +100,7 @@ namespace MWGui
 
         SkillList majorSkills, minorSkills, miscSkills;
         std::map<int, MWMechanics::Stat<float> > skillValues;
-        std::map<int, MyGUI::StaticTextPtr> skillWidgetMap;
+        std::map<int, MyGUI::TextBox*> skillWidgetMap;
         std::string name, raceId, birthSignId;
         ESM::Class klass;
         std::vector<MyGUI::WidgetPtr> skillWidgets; //< Skills and other information

apps/openmw/mwgui/stats_window.cpp

@@ -48,20 +48,20 @@ StatsWindow::StatsWindow (WindowManager& parWindowManager)
     getWidget(skillClientWidget, "SkillClient");
     getWidget(skillScrollerWidget, "SkillScroller");
 
-    skillScrollerWidget->eventScrollChangePosition = MyGUI::newDelegate(this, &StatsWindow::onScrollChangePosition);
+    skillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &StatsWindow::onScrollChangePosition);
     updateScroller();
 
     for (int i = 0; i < ESM::Skill::Length; ++i)
     {
         skillValues.insert(std::pair<int, MWMechanics::Stat<float> >(i, MWMechanics::Stat<float>()));
-        skillWidgetMap.insert(std::pair<int, MyGUI::StaticTextPtr>(i, nullptr));
+        skillWidgetMap.insert(std::pair<int, MyGUI::TextBox*>(i, nullptr));
     }
 
     MyGUI::WindowPtr t = static_cast<MyGUI::WindowPtr>(mMainWidget);
-    t->eventWindowChangeCoord = MyGUI::newDelegate(this, &StatsWindow::onWindowResize);
+    t->eventWindowChangeCoord += MyGUI::newDelegate(this, &StatsWindow::onWindowResize);
 }
 
-void StatsWindow::onScrollChangePosition(MyGUI::VScrollPtr scroller, size_t pos)
+void StatsWindow::onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos)
 {
     int diff = lastPos - pos;
     // Adjust position of all widget according to difference
@@ -95,10 +95,10 @@ void StatsWindow::setBar(const std::string& name, const std::string& tname, int
 
 void StatsWindow::setPlayerName(const std::string& playerName)
 {
-    mMainWidget->setCaption(playerName);
+    static_cast<MyGUI::Window*>(mMainWidget)->setCaption(playerName);
 }
 
-void StatsWindow::setStyledText(MyGUI::StaticTextPtr widget, ColorStyle style, const std::string &value)
+void StatsWindow::setStyledText(MyGUI::TextBox* widget, ColorStyle style, const std::string &value)
 {
     widget->setCaption(value);
     if (style == CS_Super)
@@ -175,7 +175,7 @@ void StatsWindow::setValue (const std::string& id, int value)
 void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
 {
     skillValues[parSkill] = value;
-    MyGUI::StaticTextPtr widget = skillWidgetMap[(int)parSkill];
+    MyGUI::TextBox* widget = skillWidgetMap[(int)parSkill];
     if (widget)
     {
         float modified = value.getModified(), base = value.getBase();
@@ -221,7 +221,7 @@ void StatsWindow::setBirthSign (const std::string& signId)
 
 void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticImagePtr separator = skillClientWidget->createWidget<MyGUI::StaticImage>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
+    MyGUI::ImageBox* separator = skillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
     skillWidgets.push_back(separator);
 
     coord1.top += separator->getHeight();
@@ -230,7 +230,7 @@ void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 
 void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr groupWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
+    MyGUI::TextBox* groupWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
     groupWidget->setCaption(label);
     skillWidgets.push_back(groupWidget);
 
@@ -238,14 +238,14 @@ void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, My
     coord2.top += lineHeight;
 }
 
-MyGUI::StaticTextPtr StatsWindow::addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
+MyGUI::TextBox* StatsWindow::addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr skillNameWidget, skillValueWidget;
+    MyGUI::TextBox *skillNameWidget, *skillValueWidget;
 
-    skillNameWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandText", coord1, MyGUI::Align::Default);
+    skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Default);
     skillNameWidget->setCaption(text);
 
-    skillValueWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandTextRight", coord2, MyGUI::Align::Default);
+    skillValueWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Default);
     setStyledText(skillValueWidget, style, value);
 
     skillWidgets.push_back(skillNameWidget);
@@ -259,9 +259,9 @@ MyGUI::StaticTextPtr StatsWindow::addValueItem(const std::string text, const std
 
 void StatsWindow::addItem(const std::string text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
 {
-    MyGUI::StaticTextPtr skillNameWidget;
+    MyGUI::TextBox* skillNameWidget;
 
-    skillNameWidget = skillClientWidget->createWidget<MyGUI::StaticText>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
+    skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
     skillNameWidget->setCaption(text);
 
     skillWidgets.push_back(skillNameWidget);
@@ -297,7 +297,7 @@ void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId,
             style = CS_Super;
         else if (modified < base)
             style = CS_Sub;
-        MyGUI::StaticTextPtr widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), style, coord1, coord2);
+        MyGUI::TextBox* widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), style, coord1, coord2);
         skillWidgetMap[skillId] = widget;
     }
 }

apps/openmw/mwgui/stats_window.hpp

@@ -49,26 +49,26 @@ namespace MWGui
                 CS_Normal,
                 CS_Super
             };
-            void setStyledText(MyGUI::StaticTextPtr widget, ColorStyle style, const std::string &value);
+            void setStyledText(MyGUI::TextBox* widget, ColorStyle style, const std::string &value);
             void addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
             void addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
             void addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
-            MyGUI::StaticTextPtr addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
+            MyGUI::TextBox* addValueItem(const std::string text, const std::string &value, ColorStyle style, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
             void addItem(const std::string text, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2);
             void updateScroller();
 
-            void onScrollChangePosition(MyGUI::VScrollPtr scroller, size_t pos);
+            void onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos);
             void onWindowResize(MyGUI::Window* window);
 
             static const int lineHeight;
 
             MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
-            MyGUI::VScrollPtr skillScrollerWidget;
+            MyGUI::ScrollBar* skillScrollerWidget;
             int lastPos, clientHeight;
 
             SkillList majorSkills, minorSkills, miscSkills;
             std::map<int, MWMechanics::Stat<float> > skillValues;
-            std::map<int, MyGUI::StaticTextPtr> skillWidgetMap;
+            std::map<int, MyGUI::TextBox*> skillWidgetMap;
             std::map<std::string, MyGUI::WidgetPtr> factionWidgetMap;
             FactionList factions; ///< Stores a list of factions and the current rank
             std::string birthSignId;

apps/openmw/mwgui/text_input.cpp

@@ -10,12 +10,12 @@ TextInputDialog::TextInputDialog(WindowManager& parWindowManager)
     center();
 
     getWidget(textEdit, "TextEdit");
-    textEdit->eventEditSelectAccept = newDelegate(this, &TextInputDialog::onTextAccepted);
+    textEdit->eventEditSelectAccept += newDelegate(this, &TextInputDialog::onTextAccepted);
 
     // TODO: These buttons should be managed by a Dialog class
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->eventMouseButtonClick = MyGUI::newDelegate(this, &TextInputDialog::onOkClicked);
+    okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TextInputDialog::onOkClicked);
 
     // Make sure the edit box has focus
     MyGUI::InputManager::getInstance().setKeyFocusWidget(textEdit);

apps/openmw/mwgui/widgets.cpp

@@ -62,24 +62,24 @@ void MWSkill::updateWidgets()
     {
         if (skillId == ESM::Skill::Length)
         {
-            skillNameWidget->setCaption("");
+            static_cast<MyGUI::TextBox*>(skillNameWidget)->setCaption("");
         }
         else
         {
             const std::string &name = manager->getGameSettingString(ESM::Skill::sSkillNameIds[skillId], "");
-            skillNameWidget->setCaption(name);
+            static_cast<MyGUI::TextBox*>(skillNameWidget)->setCaption(name);
         }
     }
     if (skillValueWidget)
     {
         SkillValue::Type modified = value.getModified(), base = value.getBase();
-        skillValueWidget->setCaption(boost::lexical_cast<std::string>(modified));
+        static_cast<MyGUI::TextBox*>(skillValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
         if (modified > base)
-            skillValueWidget->setState("increased");
+            skillValueWidget->_setWidgetState("increased");
         else if (modified < base)
-            skillValueWidget->setState("decreased");
+            skillValueWidget->_setWidgetState("decreased");
         else
-            skillValueWidget->setState("normal");
+            skillValueWidget->_setWidgetState("normal");
     }
 }
 
@@ -88,59 +88,32 @@ void MWSkill::onClicked(MyGUI::Widget* _sender)
     eventClicked(this);
 }
 
-void MWSkill::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
-{
-    Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
-
-    initialiseWidgetSkin(_info);
-}
-
 MWSkill::~MWSkill()
 {
-    shutdownWidgetSkin();
 }
 
-void MWSkill::baseChangeWidgetSkin(ResourceSkin* _info)
+void MWSkill::initialiseOverride()
 {
-    shutdownWidgetSkin();
+    Base::initialiseOverride();
-    Base::baseChangeWidgetSkin(_info);
-    initialiseWidgetSkin(_info);
-}
 
-void MWSkill::initialiseWidgetSkin(ResourceSkin* _info)
+    assignWidget(skillNameWidget, "StatName");
-{
+    assignWidget(skillValueWidget, "StatValue");
-    for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
+
+    MyGUI::ButtonPtr button;
+    assignWidget(button, "StatNameButton");
+    if (button)
     {
-        const std::string &name = *(*iter)->_getInternalData<std::string>();
+        skillNameWidget = button;
-        if (name == "StatName")
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWSkill::onClicked);
-        {
-            MYGUI_DEBUG_ASSERT( ! skillNameWidget, "widget already assigned");
-            skillNameWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "StatValue")
-        {
-            MYGUI_DEBUG_ASSERT( ! skillValueWidget, "widget already assigned");
-            skillValueWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "StatNameButton")
-        {
-            MYGUI_DEBUG_ASSERT( ! skillNameWidget, "widget already assigned");
-            MyGUI::ButtonPtr button = (*iter)->castType<Button>();
-            skillNameWidget = button;
-            button->eventMouseButtonClick = MyGUI::newDelegate(this, &MWSkill::onClicked);
-        }
-        else if (name == "StatValueButton")
-        {
-            MYGUI_DEBUG_ASSERT( ! skillValueWidget, "widget already assigned");
-            MyGUI::ButtonPtr button = (*iter)->castType<Button>();
-            skillNameWidget = button;
-            button->eventMouseButtonClick = MyGUI::newDelegate(this, &MWSkill::onClicked);
-        }
     }
-}
 
-void MWSkill::shutdownWidgetSkin()
+    button = 0;
-{
+    assignWidget(button, "StatValueButton");
+    if (button)
+    {
+        skillNameWidget = button;
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWSkill::onClicked);
+    }
 }
 
 /* MWAttribute */
@@ -176,7 +149,7 @@ void MWAttribute::updateWidgets()
     {
         if (id < 0 || id >= 8)
         {
-            attributeNameWidget->setCaption("");
+            static_cast<MyGUI::TextBox*>(attributeNameWidget)->setCaption("");
         }
         else
         {
@@ -191,75 +164,48 @@ void MWAttribute::updateWidgets()
                 "sAttributeLuck"
             };
             const std::string &name = manager->getGameSettingString(attributes[id], "");
-            attributeNameWidget->setCaption(name);
+            static_cast<MyGUI::TextBox*>(attributeNameWidget)->setCaption(name);
         }
     }
     if (attributeValueWidget)
     {
         AttributeValue::Type modified = value.getModified(), base = value.getBase();
-        attributeValueWidget->setCaption(boost::lexical_cast<std::string>(modified));
+        static_cast<MyGUI::TextBox*>(attributeValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
         if (modified > base)
-            attributeValueWidget->setState("increased");
+            attributeValueWidget->_setWidgetState("increased");
         else if (modified < base)
-            attributeValueWidget->setState("decreased");
+            attributeValueWidget->_setWidgetState("decreased");
         else
-            attributeValueWidget->setState("normal");
+            attributeValueWidget->_setWidgetState("normal");
     }
 }
 
-void MWAttribute::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
-{
-    Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
-
-    initialiseWidgetSkin(_info);
-}
-
 MWAttribute::~MWAttribute()
 {
-    shutdownWidgetSkin();
 }
 
-void MWAttribute::baseChangeWidgetSkin(ResourceSkin* _info)
+void MWAttribute::initialiseOverride()
 {
-    shutdownWidgetSkin();
+    Base::initialiseOverride();
-    Base::baseChangeWidgetSkin(_info);
-    initialiseWidgetSkin(_info);
-}
 
-void MWAttribute::initialiseWidgetSkin(ResourceSkin* _info)
+    assignWidget(attributeNameWidget, "StatName");
-{
+    assignWidget(attributeValueWidget, "StatValue");
-    for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
+    
+    MyGUI::ButtonPtr button;
+    assignWidget(button, "StatNameButton");
+    if (button)
     {
-        const std::string &name = *(*iter)->_getInternalData<std::string>();
+        attributeNameWidget = button;
-        if (name == "StatName")
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWAttribute::onClicked);
-        {
-            MYGUI_DEBUG_ASSERT( ! attributeNameWidget, "widget already assigned");
-            attributeNameWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "StatValue")
-        {
-            MYGUI_DEBUG_ASSERT( ! attributeValueWidget, "widget already assigned");
-            attributeValueWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "StatNameButton")
-        {
-            MYGUI_DEBUG_ASSERT( ! attributeNameWidget, "widget already assigned");
-            MyGUI::ButtonPtr button = (*iter)->castType<Button>();
-            attributeNameWidget = button;
-            button->eventMouseButtonClick = MyGUI::newDelegate(this, &MWAttribute::onClicked);
-        }
-        else if (name == "StatValue")
-        {
-            MYGUI_DEBUG_ASSERT( ! attributeValueWidget, "widget already assigned");
-            MyGUI::ButtonPtr button = (*iter)->castType<Button>();
-            attributeNameWidget = button;
-            button->eventMouseButtonClick = MyGUI::newDelegate(this, &MWAttribute::onClicked);
-        }
     }
-}
 
-void MWAttribute::shutdownWidgetSkin()
+    button = 0;
-{
+    assignWidget(button, "StatValueButton");
+    if (button)
+    {
+        attributeValueWidget = button;
+        button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWAttribute::onClicked);
+    }
 }
 
 /* MWSpell */
@@ -301,45 +247,20 @@ void MWSpell::updateWidgets()
         const ESMS::ESMStore &store = mWindowManager->getStore();
         const ESM::Spell *spell = store.spells.search(id);
         if (spell)
-            spellNameWidget->setCaption(spell->name);
+            static_cast<MyGUI::TextBox*>(spellNameWidget)->setCaption(spell->name);
         else
-            spellNameWidget->setCaption("");
+            static_cast<MyGUI::TextBox*>(spellNameWidget)->setCaption("");
     }
 }
 
-void MWSpell::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
+void MWSpell::initialiseOverride()
 {
-    Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
+    Base::initialiseOverride();
 
-    initialiseWidgetSkin(_info);
+    assignWidget(spellNameWidget, "StatName");
 }
 
 MWSpell::~MWSpell()
-{
-    shutdownWidgetSkin();
-}
-
-void MWSpell::baseChangeWidgetSkin(ResourceSkin* _info)
-{
-    shutdownWidgetSkin();
-    Base::baseChangeWidgetSkin(_info);
-    initialiseWidgetSkin(_info);
-}
-
-void MWSpell::initialiseWidgetSkin(ResourceSkin* _info)
-{
-    for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
-    {
-        const std::string &name = *(*iter)->_getInternalData<std::string>();
-        if (name == "StatName")
-        {
-            MYGUI_DEBUG_ASSERT( ! spellNameWidget, "widget already assigned");
-            spellNameWidget = (*iter)->castType<StaticText>();
-        }
-    }
-}
-
-void MWSpell::shutdownWidgetSkin()
 {
 }
 
@@ -408,10 +329,10 @@ void MWSpellEffect::updateWidgets()
                 spellLine += " on Touch";
             else if (effect.range == ESM::RT_Target)
                 spellLine += " on Target";
-            textWidget->setCaption(spellLine);
+            static_cast<MyGUI::TextBox*>(textWidget)->setCaption(spellLine);
         }
         else
-            textWidget->setCaption("");
+            static_cast<MyGUI::TextBox*>(textWidget)->setCaption("");
     }
     if (imageWidget)
     {
@@ -421,45 +342,16 @@ void MWSpellEffect::updateWidgets()
     }
 }
 
-void MWSpellEffect::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
-{
-    Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
-
-    initialiseWidgetSkin(_info);
-}
-
 MWSpellEffect::~MWSpellEffect()
 {
-    shutdownWidgetSkin();
 }
 
-void MWSpellEffect::baseChangeWidgetSkin(ResourceSkin* _info)
+void MWSpellEffect::initialiseOverride()
 {
-    shutdownWidgetSkin();
+    Base::initialiseOverride();
-    Base::baseChangeWidgetSkin(_info);
-    initialiseWidgetSkin(_info);
-}
 
-void MWSpellEffect::initialiseWidgetSkin(ResourceSkin* _info)
+    assignWidget(textWidget, "Text");
-{
+    assignWidget(imageWidget, "Image");
-    for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
-    {
-        const std::string &name = *(*iter)->_getInternalData<std::string>();
-        if (name == "Text")
-        {
-            MYGUI_DEBUG_ASSERT( ! textWidget, "widget already assigned");
-            textWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "Image")
-        {
-            MYGUI_DEBUG_ASSERT( ! imageWidget, "widget already assigned");
-            imageWidget = (*iter)->castType<StaticImage>();
-        }
-    }
-}
-
-void MWSpellEffect::shutdownWidgetSkin()
-{
 }
 
 /* MWDynamicStat */
@@ -491,60 +383,27 @@ void MWDynamicStat::setValue(int cur, int max_)
         {
             std::stringstream out;
             out << value << "/" << max;
-            barTextWidget->setCaption(out.str().c_str());
+            static_cast<MyGUI::TextBox*>(barTextWidget)->setCaption(out.str().c_str());
         }
         else
-            barTextWidget->setCaption("");
+            static_cast<MyGUI::TextBox*>(barTextWidget)->setCaption("");
     }
 }
 void MWDynamicStat::setTitle(const std::string text)
 {
     if (textWidget)
-        textWidget->setCaption(text);
+        static_cast<MyGUI::TextBox*>(textWidget)->setCaption(text);
-}
-
-void MWDynamicStat::_initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name)
-{
-    Base::_initialise(_style, _coord, _align, _info, _parent, _croppedParent, _creator, _name);
-
-    initialiseWidgetSkin(_info);
 }
 
 MWDynamicStat::~MWDynamicStat()
 {
-    shutdownWidgetSkin();
 }
 
-void MWDynamicStat::baseChangeWidgetSkin(ResourceSkin* _info)
+void MWDynamicStat::initialiseOverride()
 {
-    shutdownWidgetSkin();
+    Base::initialiseOverride();
-    Base::baseChangeWidgetSkin(_info);
-    initialiseWidgetSkin(_info);
-}
 
-void MWDynamicStat::initialiseWidgetSkin(ResourceSkin* _info)
+    assignWidget(textWidget, "Text");
-{
+    assignWidget(barWidget, "Bar");
-    for (VectorWidgetPtr::iterator iter=mWidgetChildSkin.begin(); iter!=mWidgetChildSkin.end(); ++iter)
+    assignWidget(barTextWidget, "BarText");
-    {
-        const std::string &name = *(*iter)->_getInternalData<std::string>();
-        if (name == "Text")
-        {
-            MYGUI_DEBUG_ASSERT( ! textWidget, "widget already assigned");
-            textWidget = (*iter)->castType<StaticText>();
-        }
-        else if (name == "Bar")
-        {
-            MYGUI_DEBUG_ASSERT( ! barWidget, "widget already assigned");
-            barWidget = (*iter)->castType<Progress>();
-        }
-        else if (name == "BarText")
-        {
-            MYGUI_DEBUG_ASSERT( ! barTextWidget, "widget already assigned");
-            barTextWidget = (*iter)->castType<StaticText>();
-        }
-    }
-}
-
-void MWDynamicStat::shutdownWidgetSkin()
-{
 }

apps/openmw/mwgui/widgets.hpp

@@ -38,26 +38,21 @@ namespace MWGui
             const SkillValue& getSkillValue() const { return value; }
 
             // Events
-            typedef delegates::CDelegate1<MWSkill*> EventHandle_SkillVoid;
+            typedef delegates::CMultiDelegate1<MWSkill*> EventHandle_SkillVoid;
 
             /** Event : Skill clicked.\n
                 signature : void method(MWSkill* _sender)\n
             */
             EventHandle_SkillVoid eventClicked;
 
-        /*internal:*/
-            virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
         protected:
             virtual ~MWSkill();
 
-            void baseChangeWidgetSkin(ResourceSkin* _info);
+            virtual void initialiseOverride();
 
             void onClicked(MyGUI::Widget* _sender);
 
         private:
-            void initialiseWidgetSkin(ResourceSkin* _info);
-            void shutdownWidgetSkin();
 
             void updateWidgets();
 
@@ -85,26 +80,21 @@ namespace MWGui
             const AttributeValue& getAttributeValue() const { return value; }
 
             // Events
-            typedef delegates::CDelegate1<MWAttribute*> EventHandle_AttributeVoid;
+            typedef delegates::CMultiDelegate1<MWAttribute*> EventHandle_AttributeVoid;
 
             /** Event : Attribute clicked.\n
                 signature : void method(MWAttribute* _sender)\n
             */
             EventHandle_AttributeVoid eventClicked;
 
-        /*internal:*/
-            virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
         protected:
             virtual ~MWAttribute();
 
-            void baseChangeWidgetSkin(ResourceSkin* _info);
+            virtual void initialiseOverride();
 
             void onClicked(MyGUI::Widget* _sender);
 
         private:
-            void initialiseWidgetSkin(ResourceSkin* _info);
-            void shutdownWidgetSkin();
 
             void updateWidgets();
 
@@ -130,23 +120,17 @@ namespace MWGui
 
             const std::string &getSpellId() const { return id; }
 
-        /*internal:*/
-            virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
         protected:
             virtual ~MWSpell();
 
-            void baseChangeWidgetSkin(ResourceSkin* _info);
+		virtual void initialiseOverride();
 
         private:
-            void initialiseWidgetSkin(ResourceSkin* _info);
-            void shutdownWidgetSkin();
-
             void updateWidgets();
 
             WindowManager* mWindowManager;
             std::string id;
-            MyGUI::StaticTextPtr spellNameWidget;
+            MyGUI::TextBox* spellNameWidget;
         };
         typedef MWSpell* MWSpellPtr;
 
@@ -163,24 +147,19 @@ namespace MWGui
 
             const SpellEffectValue &getSpellEffect() const { return effect; }
 
-        /*internal:*/
-            virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
         protected:
             virtual ~MWSpellEffect();
 
-            void baseChangeWidgetSkin(ResourceSkin* _info);
+            virtual void initialiseOverride();
-
+            
         private:
-            void initialiseWidgetSkin(ResourceSkin* _info);
-            void shutdownWidgetSkin();
 
             void updateWidgets();
 
             WindowManager* mWindowManager;
             SpellEffectValue effect;
-            MyGUI::StaticImagePtr imageWidget;
+            MyGUI::ImageBox* imageWidget;
-            MyGUI::StaticTextPtr textWidget;
+            MyGUI::TextBox* textWidget;
         };
         typedef MWSpellEffect* MWSpellEffectPtr;
 
@@ -196,22 +175,17 @@ namespace MWGui
             int getValue() const { return value; }
             int getMax() const { return max; }
 
-            /*internal:*/
-            virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
         protected:
             virtual ~MWDynamicStat();
 
-            void baseChangeWidgetSkin(ResourceSkin* _info);
+            virtual void initialiseOverride();
 
         private:
-            void initialiseWidgetSkin(ResourceSkin* _info);
-            void shutdownWidgetSkin();
 
             int value, max;
-            MyGUI::StaticTextPtr textWidget;
+            MyGUI::TextBox* textWidget;
             MyGUI::ProgressPtr barWidget;
-            MyGUI::StaticTextPtr barTextWidget;
+            MyGUI::TextBox* barTextWidget;
         };
         typedef MWDynamicStat* MWDynamicStatPtr;
 

apps/openmw/mwgui/window_base.cpp

@@ -16,7 +16,7 @@ void WindowBase::open()
 void WindowBase::center()
 {
     // Centre dialog
-    MyGUI::IntSize gameWindowSize = mWindowManager.getGui()->getViewSize();
+    MyGUI::IntSize gameWindowSize = MyGUI::RenderManager::getInstance().getViewSize();
     MyGUI::IntCoord coord = mMainWidget->getCoord();
     coord.left = (gameWindowSize.width - coord.width)/2;
     coord.top = (gameWindowSize.height - coord.height)/2;

apps/openmw/mwgui/window_base.hpp

@@ -13,7 +13,7 @@ namespace MWGui
         WindowBase(const std::string& parLayout, WindowManager& parWindowManager);
 
         // Events
-        typedef MyGUI::delegates::CDelegate1<WindowBase*> EventHandle_WindowBase;
+        typedef MyGUI::delegates::CMultiDelegate1<WindowBase*> EventHandle_WindowBase;
 
         virtual void open();
         void center();

apps/openmw/mwgui/window_manager.cpp

@@ -37,12 +37,12 @@ WindowManager::WindowManager(MWWorld::Environment& environment,
     gui = mGuiManager->getGui();
 
     //Register own widgets with MyGUI
-    MyGUI::FactoryManager::getInstance().registerFactory<DialogeHistory>("Widget");
+    MyGUI::FactoryManager::getInstance().registerFactory<DialogueHistory>("Widget");
 
     // Get size info from the Gui object
     assert(gui);
-    int w = gui->getViewSize().width;
+    int w = MyGUI::RenderManager::getInstance().getViewSize().width;
-    int h = gui->getViewSize().height;
+    int h = MyGUI::RenderManager::getInstance().getViewSize().height;
 
     hud = new HUD(w,h, showFPSLevel);
     menu = new MainMenu(w,h);
@@ -51,6 +51,7 @@ WindowManager::WindowManager(MWWorld::Environment& environment,
     console = new Console(w,h, environment, extensions);
     mJournal = new JournalWindow(*this);
     mMessageBoxManager = new MessageBoxManager(this);
+    dialogueWindow = new DialogueWindow(*this,environment);
 
     // The HUD is always on
     hud->setVisible(true);
@@ -149,9 +150,10 @@ void WindowManager::updateVisible()
     stats->setVisible(false);
     console->disable();
     mJournal->setVisible(false);
+    dialogueWindow->setVisible(false);
 
     // Mouse is visible whenever we're not in game mode
-    gui->setVisiblePointer(isGuiMode());
+    MyGUI::PointerManager::getInstance().setVisible(isGuiMode());
 
     // If in game mode, don't show anything.
     if(mode == GM_Game) //Use a switch/case structure
@@ -195,11 +197,6 @@ void WindowManager::updateVisible()
 
     if (mode == GM_Dialogue)
     {
-        if (!dialogueWindow)
-        {
-            dialogueWindow = new DialogueWindow(*this);
-            dialogueWindow->eventBye = MyGUI::newDelegate(this, &WindowManager::onDialogueWindowBye);
-        }
         dialogueWindow->open();
         return;
     }
@@ -349,6 +346,7 @@ void WindowManager::updateSkillArea()
 
 void WindowManager::removeDialog(OEngine::GUI::Layout*dialog)
 {
+    std::cout << "dialogue a la poubelle";
     assert(dialog);
     if (!dialog)
         return;
@@ -387,7 +385,8 @@ void WindowManager::onDialogueWindowBye()
     if (dialogueWindow)
     {
         //FIXME set some state and stuff?
-        removeDialog(dialogueWindow);
+        //removeDialog(dialogueWindow);
+        dialogueWindow->setVisible(false);
     }
     setGuiMode(GM_Game);
 }

apps/openmw/mwgui/window_manager.hpp

@@ -124,6 +124,8 @@ namespace MWGui
       updateVisible();
     }
 
+    MWGui::DialogueWindow* getDialogueWindow() {return dialogueWindow;}
+
     MyGUI::Gui* getGui() const { return gui; }
 
     void wmUpdateFps(float fps, size_t triangleCount, size_t batchCount)

apps/openmw/mwscript/dialogueextensions.cpp

@@ -8,6 +8,7 @@
 #include <components/interpreter/opcodes.hpp>
 
 #include "../mwdialogue/journal.hpp"
+#include "../mwdialogue/dialoguemanager.hpp"
 
 #include "interpretercontext.hpp"
 
@@ -72,15 +73,62 @@ namespace MWScript
                 }
         };
 
+        class OpAddTopic : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    MWScript::InterpreterContext& context
+                        = static_cast<MWScript::InterpreterContext&> (runtime.getContext());
+
+                    std::string topic = runtime.getStringLiteral (runtime[0].mInteger);
+                    runtime.pop();
+
+                    context.getEnvironment().mDialogueManager->addTopic(topic);
+                }
+        };
+
+        class OpChoice : public Interpreter::Opcode1
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime, unsigned int arg0)
+                {
+                    MWScript::InterpreterContext& context
+                        = static_cast<MWScript::InterpreterContext&> (runtime.getContext());
+                    MWDialogue::DialogueManager* dialogue = context.getEnvironment().mDialogueManager;
+                    while(arg0>0)
+                    {
+                        std::string question = runtime.getStringLiteral (runtime[0].mInteger);
+                        runtime.pop();
+                        arg0 = arg0 -1;
+                        Interpreter::Type_Integer choice = 1;
+                        if(arg0>0)
+                        {
+                            choice = runtime[0].mInteger;
+                            runtime.pop();
+                            arg0 = arg0 -1;
+                        }
+                        dialogue->askQuestion(question,choice);
+                    }
+                }
+        };
+
+
         const int opcodeJournal = 0x2000133;
         const int opcodeSetJournalIndex = 0x2000134;
         const int opcodeGetJournalIndex = 0x2000135;
+        const int opcodeAddTopic = 0x200013a;
+        const int opcodeChoice = 0x2000a;
 
         void registerExtensions (Compiler::Extensions& extensions)
         {
             extensions.registerInstruction ("journal", "cl", opcodeJournal);
             extensions.registerInstruction ("setjournalindex", "cl", opcodeSetJournalIndex);
             extensions.registerFunction ("getjournalindex", 'l', "c", opcodeGetJournalIndex);
+            extensions.registerInstruction ("addtopic", "S" , opcodeAddTopic);
+            extensions.registerInstruction ("choice", "/SlSlSlSlSlSlSlSlSlSlSlSlSlSlSlSl", opcodeChoice);
         }
 
         void installOpcodes (Interpreter::Interpreter& interpreter)
@@ -88,6 +136,8 @@ namespace MWScript
             interpreter.installSegment5 (opcodeJournal, new OpJournal);
             interpreter.installSegment5 (opcodeSetJournalIndex, new OpSetJournalIndex);
             interpreter.installSegment5 (opcodeGetJournalIndex, new OpGetJournalIndex);
+            interpreter.installSegment5 (opcodeAddTopic, new OpAddTopic);
+            interpreter.installSegment3 (opcodeChoice,new OpChoice);
         }
     }
 

apps/openmw/mwscript/docs/vmformat.txt

@@ -23,7 +23,8 @@ op 0x20006: PlayAnim
 op 0x20007: PlayAnim, explicit reference
 op 0x20008: LoopAnim
 op 0x20009: LoopAnim, explicit reference
-opcodes 0x2000a-0x3ffff unused
+op 0x2000a: Choice
+opcodes 0x2000b-0x3ffff unused
 
 Segment 4:
 (not implemented yet)
@@ -115,6 +116,7 @@ op 0x2000136: GetPCCell
 op 0x2000137: GetButtonPressed
 op 0x2000138: SkipAnim
 op 0x2000139: SkipAnim, expplicit reference
+op 0x200013a: AddTopic
 op 0x200013b: twf
 op 0x200013c: FadeIn
 op 0x200013d: FadeOut

apps/openmw/mwscript/scriptmanager.cpp

@@ -63,7 +63,7 @@ namespace MWScript
             {
                 std::vector<Interpreter::Type_Code> code;
                 mParser.getCode (code);
-                mScripts.insert (std::make_pair (name, code));
+                mScripts.insert (std::make_pair (name, std::make_pair (code, mParser.getLocals())));
 
                 // TODO sanity check on generated locals
 
@@ -77,8 +77,7 @@ namespace MWScript
     void ScriptManager::run (const std::string& name, Interpreter::Context& interpreterContext)
     {
         // compile script
-        std::map<std::string, std::vector<Interpreter::Type_Code> >::iterator iter =
+        ScriptCollection::iterator iter = mScripts.find (name);
-            mScripts.find (name);
 
         if (iter==mScripts.end())
         {
@@ -86,7 +85,7 @@ namespace MWScript
             {
                 // failed -> ignore script from now on.
                 std::vector<Interpreter::Type_Code> empty;
-                mScripts.insert (std::make_pair (name, empty));
+                mScripts.insert (std::make_pair (name, std::make_pair (empty, Compiler::Locals())));
                 return;
             }
 
@@ -95,7 +94,7 @@ namespace MWScript
         }
 
         // execute script
-        if (!iter->second.empty())
+        if (!iter->second.first.empty())
             try
             {
                 if (!mOpcodesInstalled)
@@ -104,7 +103,7 @@ namespace MWScript
                     mOpcodesInstalled = true;
                 }
 
-                mInterpreter.run (&iter->second[0], iter->second.size(), interpreterContext);
+                mInterpreter.run (&iter->second.first[0], iter->second.first.size(), interpreterContext);
             }
             catch (const std::exception& e)
             {
@@ -113,7 +112,7 @@ namespace MWScript
                 if (mVerbose)
                     std::cerr << "(" << e.what() << ")" << std::endl;
 
-                iter->second.clear(); // don't execute again.
+                iter->second.first.clear(); // don't execute again.
             }
     }
 
@@ -132,4 +131,24 @@ namespace MWScript
 
         return std::make_pair (count, success);
     }
+
+    Compiler::Locals& ScriptManager::getLocals (const std::string& name)
+    {
+        ScriptCollection::iterator iter = mScripts.find (name);
+
+        if (iter==mScripts.end())
+        {
+            if (!compile (name))
+            {
+                // failed -> ignore script from now on.
+                std::vector<Interpreter::Type_Code> empty;
+                mScripts.insert (std::make_pair (name, std::make_pair (empty, Compiler::Locals())));
+                throw std::runtime_error ("failed to compile script " + name);
+            }
+
+            iter = mScripts.find (name);
+        }
+
+        return iter->second.second;
+    }
 }

apps/openmw/mwscript/scriptmanager.hpp

@@ -39,7 +39,11 @@ namespace MWScript
             Interpreter::Interpreter mInterpreter;
             bool mOpcodesInstalled;
 
-            std::map<std::string, std::vector<Interpreter::Type_Code> > mScripts;
+            typedef std::pair<std::vector<Interpreter::Type_Code>, Compiler::Locals> CompiledScript;
+            typedef std::map<std::string, CompiledScript> ScriptCollection;
+
+
+            ScriptCollection mScripts;
 
         public:
 
@@ -56,6 +60,9 @@ namespace MWScript
             std::pair<int, int> compileAll();
             ///< Compile all scripts
             /// \return count, success
+
+            Compiler::Locals& getLocals (const std::string& name);
+            ///< Return locals for script \a name.
     };
 };
 

apps/openmw/mwworld/containerstore.cpp

@@ -8,6 +8,29 @@
 #include <components/esm/loadcont.hpp>
 
 #include "manualref.hpp"
+#include "refdata.hpp"
+
+namespace
+{
+    template<typename T>
+    float getTotalWeight (const ESMS::CellRefList<T, MWWorld::RefData>& cellRefList)
+    {
+        float sum = 0;
+
+        for (typename ESMS::CellRefList<T, MWWorld::RefData>::List::const_iterator iter (
+            cellRefList.list.begin());
+            iter!=cellRefList.list.end();
+            ++iter)
+        {
+            if (iter->mData.getCount()>0)
+                sum += iter->mData.getCount()*iter->base->data.weight;
+        }
+
+        return sum;
+    }
+}
+
+MWWorld::ContainerStore::ContainerStore() : mStateId (0), mCachedWeight (0), mWeightUpToDate (false) {}
 
 MWWorld::ContainerStore::~ContainerStore() {}
 
@@ -40,6 +63,8 @@ void MWWorld::ContainerStore::add (const Ptr& ptr)
         case Type_Repair: repairs.list.push_back (*ptr.get<ESM::Repair>());  break;
         case Type_Weapon: weapons.list.push_back (*ptr.get<ESM::Weapon>());  break;
     }
+
+    flagAsModified();
 }
 
 void MWWorld::ContainerStore::fill (const ESM::InventoryList& items, const ESMS::ESMStore& store)
@@ -58,6 +83,8 @@ void MWWorld::ContainerStore::fill (const ESM::InventoryList& items, const ESMS:
         ref.getPtr().getRefData().setCount (iter->count);
         add (ref.getPtr());
     }
+
+    flagAsModified();
 }
 
 void MWWorld::ContainerStore::clear()
@@ -74,6 +101,44 @@ void MWWorld::ContainerStore::clear()
     probes.list.clear();
     repairs.list.clear();
     weapons.list.clear();
+
+    flagAsModified();
+}
+
+void MWWorld::ContainerStore::flagAsModified()
+{
+    ++mStateId;
+    mWeightUpToDate = false;
+}
+
+int MWWorld::ContainerStore::getStateId() const
+{
+    return mStateId;
+}
+
+float MWWorld::ContainerStore::getWeight() const
+{
+    if (!mWeightUpToDate)
+    {
+        mCachedWeight = 0;
+
+        mCachedWeight += getTotalWeight (potions);
+        mCachedWeight += getTotalWeight (appas);
+        mCachedWeight += getTotalWeight (armors);
+        mCachedWeight += getTotalWeight (books);
+        mCachedWeight += getTotalWeight (clothes);
+        mCachedWeight += getTotalWeight (ingreds);
+        mCachedWeight += getTotalWeight (lights);
+        mCachedWeight += getTotalWeight (lockpicks);
+        mCachedWeight += getTotalWeight (miscItems);
+        mCachedWeight += getTotalWeight (probes);
+        mCachedWeight += getTotalWeight (repairs);
+        mCachedWeight += getTotalWeight (weapons);
+
+        mWeightUpToDate = true;
+    }
+
+    return mCachedWeight;
 }
 
 int MWWorld::ContainerStore::getType (const Ptr& ptr)
@@ -301,23 +366,30 @@ MWWorld::Ptr *MWWorld::ContainerStoreIterator::operator->() const
 
 MWWorld::Ptr MWWorld::ContainerStoreIterator::operator*() const
 {
+    Ptr ptr;
+
     switch (mType)
     {
-        case ContainerStore::Type_Potion: return MWWorld::Ptr (&*mPotion, 0);
+        case ContainerStore::Type_Potion: ptr = MWWorld::Ptr (&*mPotion, 0); break;
-        case ContainerStore::Type_Apparatus: return MWWorld::Ptr (&*mApparatus, 0);
+        case ContainerStore::Type_Apparatus: ptr = MWWorld::Ptr (&*mApparatus, 0); break;
-        case ContainerStore::Type_Armor: return MWWorld::Ptr (&*mArmor, 0);
+        case ContainerStore::Type_Armor: ptr = MWWorld::Ptr (&*mArmor, 0); break;
-        case ContainerStore::Type_Book: return MWWorld::Ptr (&*mBook, 0);
+        case ContainerStore::Type_Book: ptr = MWWorld::Ptr (&*mBook, 0); break;
-        case ContainerStore::Type_Clothing: return MWWorld::Ptr (&*mClothing, 0);
+        case ContainerStore::Type_Clothing: ptr = MWWorld::Ptr (&*mClothing, 0); break;
-        case ContainerStore::Type_Ingredient: return MWWorld::Ptr (&*mIngredient, 0);
+        case ContainerStore::Type_Ingredient: ptr = MWWorld::Ptr (&*mIngredient, 0); break;
-        case ContainerStore::Type_Light: return MWWorld::Ptr (&*mLight, 0);
+        case ContainerStore::Type_Light: ptr = MWWorld::Ptr (&*mLight, 0); break;
-        case ContainerStore::Type_Lockpick: return MWWorld::Ptr (&*mLockpick, 0);
+        case ContainerStore::Type_Lockpick: ptr = MWWorld::Ptr (&*mLockpick, 0); break;
-        case ContainerStore::Type_Miscellaneous: return MWWorld::Ptr (&*mMiscellaneous, 0);
+        case ContainerStore::Type_Miscellaneous: ptr = MWWorld::Ptr (&*mMiscellaneous, 0); break;
-        case ContainerStore::Type_Probe: return MWWorld::Ptr (&*mProbe, 0);
+        case ContainerStore::Type_Probe: ptr = MWWorld::Ptr (&*mProbe, 0); break;
-        case ContainerStore::Type_Repair: return MWWorld::Ptr (&*mRepair, 0);
+        case ContainerStore::Type_Repair: ptr = MWWorld::Ptr (&*mRepair, 0); break;
-        case ContainerStore::Type_Weapon: return MWWorld::Ptr (&*mWeapon, 0);
+        case ContainerStore::Type_Weapon: ptr = MWWorld::Ptr (&*mWeapon, 0); break;
     }
 
-    throw std::runtime_error ("invalid pointer");
+    if (ptr.isEmpty())
+        throw std::runtime_error ("invalid iterator");
+
+    ptr.setContainerStore (mContainer);
+
+    return ptr;
 }
 
 MWWorld::ContainerStoreIterator& MWWorld::ContainerStoreIterator::operator++()

apps/openmw/mwworld/containerstore.hpp

@@ -52,9 +52,14 @@ namespace MWWorld
             ESMS::CellRefList<ESM::Probe, RefData>             probes;
             ESMS::CellRefList<ESM::Repair, RefData>            repairs;
             ESMS::CellRefList<ESM::Weapon, RefData>            weapons;
+            int mStateId;
+            mutable float mCachedWeight;
+            mutable bool mWeightUpToDate;
 
         public:
 
+            ContainerStore();
+
             virtual ~ContainerStore();
 
             ContainerStoreIterator begin (int mask = Type_All);
@@ -75,6 +80,18 @@ namespace MWWorld
             void clear();
             ///< Empty container.
 
+            void flagAsModified();
+            ///< \attention This function is internal to the world model and should not be called from
+            /// outside.
+
+            int getStateId() const;
+            ///< This ID is changed every time the container is modified or items in the container
+            /// are accessed in a way that may be used to modify the item.
+            /// \note This method of change-tracking will ocasionally yield false positives.
+
+            float getWeight() const;
+            ///< Return total weight of the items contained in *this.
+
             static int getType (const Ptr& ptr);
             ///< This function throws an exception, if ptr does not point to an object, that can be
             /// put into a container.

apps/openmw/mwworld/environment.hpp

@@ -9,6 +9,7 @@ namespace MWSound
 namespace MWScript
 {
     class GlobalScripts;
+    class ScriptManager;
 }
 
 namespace MWGui
@@ -41,7 +42,7 @@ namespace MWWorld
     {
     public:
         Environment()
-        : mWorld (0), mSoundManager (0), mGlobalScripts (0), mWindowManager (0),
+        : mWorld (0), mSoundManager (0), mGlobalScripts (0), mScriptManager (0), mWindowManager (0),
           mMechanicsManager (0), mDialogueManager (0), mJournal (0), mFrameDuration (0),
           mInputManager (0)
         {}
@@ -49,6 +50,7 @@ namespace MWWorld
         World *mWorld;
         MWSound::SoundManager *mSoundManager;
         MWScript::GlobalScripts *mGlobalScripts;
+        MWScript::ScriptManager *mScriptManager;
         MWGui::WindowManager *mWindowManager;
         MWMechanics::MechanicsManager *mMechanicsManager;
         MWDialogue::DialogueManager *mDialogueManager;

apps/openmw/mwworld/inventorystore.cpp

@@ -65,6 +65,8 @@ void MWWorld::InventoryStore::equip (int slot, const ContainerStoreIterator& ite
     /// \todo unstack item pointed to by iterator if required)
 
     mSlots[slot] = iterator;
+
+    flagAsModified();
 }
 
 MWWorld::ContainerStoreIterator MWWorld::InventoryStore::getSlot (int slot)

apps/openmw/mwworld/ptr.cpp

@@ -0,0 +1,39 @@
+
+#include "ptr.hpp"
+
+#include <cassert>
+
+#include "containerstore.hpp"
+
+ESM::CellRef& MWWorld::Ptr::getCellRef() const
+{
+    assert (mCellRef);
+
+    if (mContainerStore)
+        mContainerStore->flagAsModified();
+
+    return *mCellRef;
+}
+
+MWWorld::RefData& MWWorld::Ptr::getRefData() const
+{
+    assert (mRefData);
+
+    if (mContainerStore)
+        mContainerStore->flagAsModified();
+
+    return *mRefData;
+}
+
+void MWWorld::Ptr::setContainerStore (ContainerStore *store)
+{
+    assert (store);
+    assert (!mCell);
+
+    mContainerStore = store;
+}
+
+MWWorld::ContainerStore *MWWorld::Ptr::getContainerStore() const
+{
+    return mContainerStore;
+}

apps/openmw/mwworld/ptr.hpp

@@ -13,6 +13,8 @@
 
 namespace MWWorld
 {
+    class ContainerStore;
+
     /// \brief Pointer to a LiveCellRef
 
     class Ptr
@@ -26,10 +28,11 @@ namespace MWWorld
             RefData *mRefData;
             CellStore *mCell;
             std::string mTypeName;
+            ContainerStore *mContainerStore;
 
         public:
 
-            Ptr() : mCellRef (0), mRefData (0), mCell (0) {}
+            Ptr() : mCellRef (0), mRefData (0), mCell (0), mContainerStore (0) {}
 
             bool isEmpty() const
             {
@@ -49,6 +52,7 @@ namespace MWWorld
 
             template<typename T>
             Ptr (ESMS::LiveCellRef<T, RefData> *liveCellRef, CellStore *cell)
+            : mContainerStore (0)
             {
                 mPtr = liveCellRef;
                 mCellRef = &liveCellRef->ref;
@@ -63,23 +67,21 @@ namespace MWWorld
                 return boost::any_cast<ESMS::LiveCellRef<T, RefData>*> (mPtr);
             }
 
-            ESM::CellRef& getCellRef() const
+            ESM::CellRef& getCellRef() const;
-            {
-                assert (mCellRef);
-                return *mCellRef;
-            }
 
-            RefData& getRefData() const
+            RefData& getRefData() const;
-            {
-                assert (mRefData);
-                return *mRefData;
-            }
 
             Ptr::CellStore *getCell() const
             {
                 assert (mCell);
                 return mCell;
             }
+
+            void setContainerStore (ContainerStore *store);
+            ///< Must not be called on references that are in a cell.
+
+            ContainerStore *getContainerStore() const;
+            ///< May return a 0-pointer, if reference is not in a container.
     };
 
     inline bool operator== (const Ptr& left, const Ptr& right)

apps/openmw/mwworld/weather.cpp

@@ -21,9 +21,13 @@ const std::string WeatherGlobals::mThunderSoundID0 = "Thunder0";
 const std::string WeatherGlobals::mThunderSoundID1 = "Thunder1";
 const std::string WeatherGlobals::mThunderSoundID2 = "Thunder2";
 const std::string WeatherGlobals::mThunderSoundID3 = "Thunder3";
-
+const float WeatherGlobals::mSunriseTime = 8;
+const float WeatherGlobals::mSunsetTime = 18;
+const float WeatherGlobals::mSunriseDuration = 2;
+const float WeatherGlobals::mSunsetDuration = 2;
 const float WeatherGlobals::mWeatherUpdateTime = 20.f;
 
+
 // morrowind sets these per-weather, but since they are only used by 'thunderstorm'
 // weather setting anyway, we can just as well set them globally
 const float WeatherGlobals::mThunderFrequency = .4;
@@ -267,7 +271,8 @@ WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, Environmen
     blight.mGlareView = 0;
     blight.mAmbientLoopSoundID = "blight";
     mWeatherSettings["blight"] = blight;
-    
+
+    /*
     Weather snow;
     snow.mCloudTexture = "tx_bm_sky_snow.dds";
     snow.mCloudsMaximumPercent = 1.0;
@@ -324,6 +329,7 @@ WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, Environmen
     blizzard.mGlareView = 0;
     blizzard.mAmbientLoopSoundID = "BM Blizzard";
     mWeatherSettings["blizzard"] = blizzard;
+    */
 }
 
 void WeatherManager::setWeather(const String& weather, bool instant)
@@ -505,32 +511,32 @@ void WeatherManager::update(float duration)
                 float thunder = region->data.thunder/255.f;
                 float ash = region->data.ash/255.f;
                 float blight = region->data.blight/255.f;
-                float snow = region->data.a/255.f;
+                //float snow = region->data.a/255.f;
-                float blizzard = region->data.b/255.f;
+                //float blizzard = region->data.b/255.f;
 
                 // re-scale to 100 percent
-                const float total = clear+cloudy+foggy+overcast+rain+thunder+ash+blight+snow+blizzard;
+                const float total = clear+cloudy+foggy+overcast+rain+thunder+ash+blight;//+snow+blizzard;
 
                 srand(time(NULL));
                 float random = ((rand()%100)/100.f) * total;
 
-                if (random >= snow+blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
+                //if (random > snow+blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
-                    weather = "blizzard";
+                //    weather = "blizzard";
-                else if (random >= blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
+                //else if (random > blight+ash+thunder+rain+overcast+foggy+cloudy+clear)
-                    weather = "snow";
+                //    weather = "snow";
-                else if (random >= ash+thunder+rain+overcast+foggy+cloudy+clear)
+                /*else*/ if (random > ash+thunder+rain+overcast+foggy+cloudy+clear)
                     weather = "blight";
-                else if (random >= thunder+rain+overcast+foggy+cloudy+clear)
+                else if (random > thunder+rain+overcast+foggy+cloudy+clear)
                     weather = "ashstorm";
-                else if (random >= rain+overcast+foggy+cloudy+clear)
+                else if (random > rain+overcast+foggy+cloudy+clear)
                     weather = "thunderstorm";
-                else if (random >= overcast+foggy+cloudy+clear)
+                else if (random > overcast+foggy+cloudy+clear)
                     weather = "rain";
-                else if (random >= foggy+cloudy+clear)
+                else if (random > foggy+cloudy+clear)
                     weather = "overcast";
-                else if (random >= cloudy+clear)
+                else if (random > cloudy+clear)
                     weather = "foggy";
-                else if (random >= clear)
+                else if (random > clear)
                     weather = "cloudy";
                 else
                     weather = "clear";

cmake/FindMyGUI.cmake

@@ -0,0 +1,125 @@
+# - Find MyGUI includes and library
+#
+# This module defines
+# MYGUI_INCLUDE_DIRS
+# MYGUI_LIBRARIES, the libraries to link against to use MYGUI.
+# MYGUI_LIB_DIR, the location of the libraries
+# MYGUI_FOUND, If false, do not try to use MYGUI
+#
+# Copyright © 2007, Matt Williams
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+CMAKE_POLICY(PUSH)
+include(FindPkgMacros)
+
+# IF (MYGUI_LIBRARIES AND MYGUI_INCLUDE_DIRS)
+    # SET(MYGUI_FIND_QUIETLY TRUE)
+# ENDIF (MYGUI_LIBRARIES AND MYGUI_INCLUDE_DIRS)
+
+IF (WIN32) #Windows
+    MESSAGE(STATUS "Looking for MyGUI")
+	SET(MYGUISDK $ENV{MYGUI_HOME})
+    IF (MYGUISDK)
+		findpkg_begin ( "MYGUI" )
+        MESSAGE(STATUS "Using MyGUI in OGRE SDK")
+		STRING(REGEX REPLACE "[\\]" "/" MYGUISDK "${MYGUISDK}" )
+
+		find_path ( MYGUI_INCLUDE_DIRS
+		  MyGUI.h 
+		  "${MYGUISDK}/MyGUIEngine/include"
+		  NO_DEFAULT_PATH )
+		  
+		find_path ( MYGUI_PLATFORM_INCLUDE_DIRS
+		  MyGUI_OgrePlatform.h
+		  "${MYGUISDK}/Platforms/Ogre/OgrePlatform/include"
+		  NO_DEFAULT_PATH )		  
+
+		SET ( MYGUI_LIB_DIR ${MYGUISDK}/*/lib )
+		
+		find_library ( MYGUI_LIBRARIES_REL NAMES
+		MyGUIEngine.lib 
+		MyGUI.OgrePlatform.lib
+		HINTS
+		${MYGUI_LIB_DIR}
+		PATH_SUFFIXES "" release relwithdebinfo minsizerel )
+
+		find_library ( MYGUI_LIBRARIES_DBG NAMES
+		MyGUIEngine_d.lib 
+		MyGUI.OgrePlatform_d.lib
+		HINTS
+		${MYGUI_LIB_DIR}
+		PATH_SUFFIXES "" debug )
+
+		find_library ( MYGUI_PLATFORM_LIBRARIES_REL NAMES
+		MyGUI.OgrePlatform.lib
+		HINTS
+		${MYGUI_LIB_DIR}
+		PATH_SUFFIXES "" release relwithdebinfo minsizerel )
+
+		find_library ( MYGUI_PLATFORM_LIBRARIES_DBG NAMES
+		MyGUI.OgrePlatform_d.lib
+		HINTS
+		${MYGUI_LIB_DIR}
+		PATH_SUFFIXES "" debug )
+		
+		make_library_set ( MYGUI_LIBRARIES )
+		make_library_set ( MYGUI_PLATFORM_LIBRARIES )
+		
+		MESSAGE ("${MYGUI_LIBRARIES}")
+		MESSAGE ("${MYGUI_PLATFORM_LIBRARIES}")
+
+		findpkg_finish ( "MYGUI" )
+
+    ENDIF (MYGUISDK)
+    IF (OGRESOURCE)
+        MESSAGE(STATUS "Using MyGUI in OGRE dependencies")
+        STRING(REGEX REPLACE "[\\]" "/" OGRESDK "${OGRESOURCE}" )
+        SET(MYGUI_INCLUDE_DIRS ${OGRESOURCE}/OgreMain/include/MYGUI)
+        SET(MYGUI_LIB_DIR ${OGRESOURCE}/lib)
+        SET(MYGUI_LIBRARIES debug Debug/MyGUIEngine_d optimized Release/MyGUIEngine)
+    ENDIF (OGRESOURCE)
+ELSE (WIN32) #Unix
+    CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
+    FIND_PACKAGE(PkgConfig)
+    PKG_SEARCH_MODULE(MYGUI MYGUI MyGUI)
+    IF (MYGUI_INCLUDE_DIRS)
+        SET(MYGUI_INCLUDE_DIRS ${MYGUI_INCLUDE_DIRS})
+        SET(MYGUI_LIB_DIR ${MYGUI_LIBDIR})
+        SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} CACHE STRING "")
+    ELSE (MYGUI_INCLUDE_DIRS)
+        FIND_PATH(MYGUI_INCLUDE_DIRS MyGUI.h PATHS /usr/local/include /usr/include PATH_SUFFIXES MyGUI MYGUI)
+        FIND_LIBRARY(MYGUI_LIBRARIES mygui PATHS /usr/lib /usr/local/lib)
+        SET(MYGUI_LIB_DIR ${MYGUI_LIBRARIES})
+        STRING(REGEX REPLACE "(.*)/.*" "\\1" MYGUI_LIB_DIR "${MYGUI_LIB_DIR}")
+        STRING(REGEX REPLACE ".*/" "" MYGUI_LIBRARIES "${MYGUI_LIBRARIES}")
+    ENDIF (MYGUI_INCLUDE_DIRS)
+ENDIF (WIN32)
+
+#Do some preparation
+SEPARATE_ARGUMENTS(MYGUI_INCLUDE_DIRS)
+SEPARATE_ARGUMENTS(MYGUI_LIBRARIES)
+SEPARATE_ARGUMENTS(MYGUI_PLATFORM_LIBRARIES)
+
+SET(MYGUI_INCLUDE_DIRS ${MYGUI_INCLUDE_DIRS} CACHE PATH "")
+SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} CACHE STRING "")
+SET(MYGUI_LIBRARIES ${MYGUI_PLATFORM_LIBRARIES} CACHE STRING "")
+SET(MYGUI_LIB_DIR ${MYGUI_LIB_DIR} CACHE PATH "")
+
+IF (MYGUI_INCLUDE_DIRS AND MYGUI_LIBRARIES)
+    SET(MYGUI_FOUND TRUE)
+ENDIF (MYGUI_INCLUDE_DIRS AND MYGUI_LIBRARIES)
+
+IF (MYGUI_FOUND)
+	MARK_AS_ADVANCED(MYGUI_LIB_DIR)
+    IF (NOT MYGUI_FIND_QUIETLY)
+        MESSAGE(STATUS " libraries : ${MYGUI_LIBRARIES} from ${MYGUI_LIB_DIR}")
+        MESSAGE(STATUS " includes : ${MYGUI_INCLUDE_DIRS}")
+    ENDIF (NOT MYGUI_FIND_QUIETLY)
+ELSE (MYGUI_FOUND)
+    IF (MYGUI_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find MYGUI")
+    ENDIF (MYGUI_FIND_REQUIRED)
+ENDIF (MYGUI_FOUND)
+
+CMAKE_POLICY(POP)

components/compiler/exprparser.cpp

@@ -639,7 +639,7 @@ namespace Compiler
         std::vector<Interpreter::Type_Code>& code, bool invert)
     {
         bool optional = false;
-        bool optionalCount = 0;
+        int optionalCount = 0;
 
         ExprParser parser (getErrorHandler(), getContext(), mLocals, mLiterals, true);
         StringParser stringParser (getErrorHandler(), getContext(), mLiterals);

components/compiler/scriptparser.cpp

@@ -24,7 +24,7 @@ namespace Compiler
         mLineParser.reset();
         if (mLineParser.parseName (name, loc, scanner))
             scanner.scan (mLineParser);
-        
+
         return true;
     }
 
@@ -34,22 +34,22 @@ namespace Compiler
         {
             mControlParser.reset();
             if (mControlParser.parseKeyword (keyword, loc, scanner))
-                scanner.scan (mControlParser);   
+                scanner.scan (mControlParser);
-        
+
             mControlParser.appendCode (mOutput.getCode());
-        
+
             return true;
         }
-    
+
         if (keyword==Scanner::K_end && mEnd)
         {
             return false;
         }
-    
+
         mLineParser.reset();
         if (mLineParser.parseKeyword (keyword, loc, scanner))
             scanner.scan (mLineParser);
-            
+
         return true;
     }
 
@@ -57,11 +57,11 @@ namespace Compiler
     {
         if (code==Scanner::S_newline) // empty line
             return true;
-            
+
         mLineParser.reset();
         if (mLineParser.parseSpecial (code, loc, scanner))
             scanner.scan (mLineParser);
-            
+
         return true;
     }
 
@@ -77,4 +77,3 @@ namespace Compiler
         mOutput.clear();
     }
 }
-

components/compiler/stringparser.cpp

@@ -39,6 +39,11 @@ namespace Compiler
             mState = CommaState;
             return true;
         }
+        else if (code==Scanner::S_newline && mState==StartState)
+        {
+            scanner.putbackSpecial (code, loc);
+            return false;
+        }
 
         return Parser::parseSpecial (code, loc, scanner);
     }

extern/mygui_3.0.1/COPYING.LESSER

@@ -1,165 +0,0 @@
-		   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions. 
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version. 
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

extern/mygui_3.0.1/MyGUIEngine/CMakeLists.txt

@@ -1,35 +0,0 @@
-set (PROJECT_NAME MyGUIEngine)
-
-project( ${PROJECT_NAME} )
-
-include(${PROJECT_NAME}.list)
-
-include_directories(include)
-if (MYGUI_USE_FREETYPE)
-	include_directories(
-		${FREETYPE_INCLUDE_DIRS}
-	)
-	add_definitions(-DMYGUI_USE_FREETYPE)
-endif ()
-
-add_definitions(-DMYGUI_BUILD)
-
-if (WIN32)
-	add_definitions(-DNOMINMAX)
-endif ()
-
-add_library(${PROJECT_NAME} ${MYGUI_LIB_TYPE} ${HEADER_FILES} ${SOURCE_FILES})
-if (MYGUI_USE_FREETYPE)
-	target_link_libraries(${PROJECT_NAME}
-		${FREETYPE_LIBRARIES}
-	)
-endif()
-
-# We don't need this lib in OS X. uuid functions is in libc here.
-if (NOT APPLE)
-	target_link_libraries(${PROJECT_NAME} ${CMAKE_DL_LIBS} uuid)
-endif(NOT APPLE)
-
-if (MINGW)
-  target_link_libraries(${PROJECT_NAME} libwinmm.a)
-endif (MINGW)

extern/mygui_3.0.1/MyGUIEngine/MyGUIEngine.list

@@ -1,561 +0,0 @@
-set (HEADER_FILES
-  include/MyGUI_Allocator.h
-  include/MyGUI_CustomAllocator.h
-  include/MyGUI_DDItemInfo.h
-  include/MyGUI_IBItemInfo.h
-  include/MyGUI_MenuItemType.h
-  include/MyGUI_MessageStyle.h
-  include/MyGUI_WidgetToolTip.h
-  include/MyGUI_Button.h
-  include/MyGUI_Canvas.h
-  include/MyGUI_ComboBox.h
-  include/MyGUI_DDContainer.h
-  include/MyGUI_Edit.h
-  include/MyGUI_HScroll.h
-  include/MyGUI_ItemBox.h
-  include/MyGUI_List.h
-  include/MyGUI_ListBox.h
-  include/MyGUI_ListCtrl.h
-  include/MyGUI_MenuBar.h
-  include/MyGUI_MenuCtrl.h
-  include/MyGUI_MenuItem.h
-  include/MyGUI_Message.h
-  include/MyGUI_MultiList.h
-  include/MyGUI_PopupMenu.h
-  include/MyGUI_Progress.h
-  include/MyGUI_ScrollView.h
-  include/MyGUI_StaticImage.h
-  include/MyGUI_StaticText.h
-  include/MyGUI_Tab.h
-  include/MyGUI_TabItem.h
-  include/MyGUI_VScroll.h
-  include/MyGUI_Widget.h
-  include/MyGUI_Window.h
-  include/MyGUI_IWidgetFactory.h
-  include/MyGUI_Bitwise.h
-  include/MyGUI_CoordConverter.h
-  include/MyGUI_DataFileStream.h
-  include/MyGUI_DataStream.h
-  include/MyGUI_Delegate.h
-  include/MyGUI_DelegateImplement.h
-  include/MyGUI_DynLib.h
-  include/MyGUI_Enumerator.h
-  include/MyGUI_EventPair.h
-  include/MyGUI_Guid.h
-  include/MyGUI_RenderOut.h
-  include/MyGUI_TextChangeHistory.h
-  include/MyGUI_TextIterator.h
-  include/MyGUI_TextureUtility.h
-  include/MyGUI_TextView.h
-  include/MyGUI_Timer.h
-  include/MyGUI_UString.h
-  include/MyGUI_Utility.h
-  include/MyGUI_WidgetTranslate.h
-  include/MyGUI_XmlDocument.h
-  include/MyGUI_LogManager.h
-  include/MyGUI_LogStream.h
-  include/MyGUI.h
-  include/MyGUI_CastWidget.h
-  include/MyGUI_Common.h
-  include/MyGUI_Diagnostic.h
-  include/MyGUI_Exception.h
-  include/MyGUI_GenericFactory.h
-  include/MyGUI_Macros.h
-  include/MyGUI_Platform.h
-  include/MyGUI_Precompiled.h
-  include/MyGUI_Prerequest.h
-  include/MyGUI_RenderFormat.h
-  include/MyGUI_ResourceHolder.h
-  include/MyGUI_WidgetDefines.h
-  include/MyGUI_ICroppedRectangle.h
-  include/MyGUI_IDataStream.h
-  include/MyGUI_Instance.h
-  include/MyGUI_IObject.h
-  include/MyGUI_ISerializable.h
-  include/MyGUI_ITexture.h
-  include/MyGUI_IUnlinkWidget.h
-  include/MyGUI_IVertexBuffer.h
-  include/MyGUI_IWidgetCreator.h
-  include/MyGUI_Plugin.h
-  include/MyGUI_RTTI.h
-  include/MyGUI_BiIndexBase.h
-  include/MyGUI_ScrollViewBase.h
-  include/MyGUI_WidgetEvent.h
-  include/MyGUI_WidgetUserData.h
-  include/MyGUI_EditText.h
-  include/MyGUI_MainSkin.h
-  include/MyGUI_RawRect.h
-  include/MyGUI_RotatingSkin.h
-  include/MyGUI_SimpleText.h
-  include/MyGUI_SubSkin.h
-  include/MyGUI_TileRect.h
-  include/MyGUI_IStateInfo.h
-  include/MyGUI_ISubWidget.h
-  include/MyGUI_ISubWidgetRect.h
-  include/MyGUI_ISubWidgetText.h
-  include/MyGUI_LayerItem.h
-  include/MyGUI_LayerNode.h
-  include/MyGUI_OverlappedLayer.h
-  include/MyGUI_RenderItem.h
-  include/MyGUI_SharedLayer.h
-  include/MyGUI_SharedLayerNode.h
-  include/MyGUI_ILayer.h
-  include/MyGUI_ILayerItem.h
-  include/MyGUI_ILayerNode.h
-  include/MyGUI_IRenderTarget.h
-  include/MyGUI_ActionController.h
-  include/MyGUI_ControllerEdgeHide.h
-  include/MyGUI_ControllerFadeAlpha.h
-  include/MyGUI_ControllerItem.h
-  include/MyGUI_ControllerPosition.h
-  include/MyGUI_ResourceImageSet.h
-  include/MyGUI_ResourceImageSetPointer.h
-  include/MyGUI_ResourceManualFont.h
-  include/MyGUI_ResourceManualPointer.h
-  include/MyGUI_ResourceSkin.h
-  include/MyGUI_ResourceTrueTypeFont.h
-  include/MyGUI_IFont.h
-  include/MyGUI_IPointer.h
-  include/MyGUI_IResource.h
-  include/MyGUI_ChildSkinInfo.h
-  include/MyGUI_FontData.h
-  include/MyGUI_MaskPickInfo.h
-  include/MyGUI_SubWidgetBinding.h
-  include/MyGUI_SubWidgetInfo.h
-  include/MyGUI_Align.h
-  include/MyGUI_Any.h
-  include/MyGUI_Colour.h
-  include/MyGUI_CommonStateInfo.h
-  include/MyGUI_ImageInfo.h
-  include/MyGUI_InputDefine.h
-  include/MyGUI_RenderTargetInfo.h
-  include/MyGUI_TCoord.h
-  include/MyGUI_TPoint.h
-  include/MyGUI_TRect.h
-  include/MyGUI_TSize.h
-  include/MyGUI_Types.h
-  include/MyGUI_Version.h
-  include/MyGUI_VertexData.h
-  include/MyGUI_WidgetStyle.h
-  include/MyGUI_ClipboardManager.h
-  include/MyGUI_ControllerManager.h
-  include/MyGUI_DataManager.h
-  include/MyGUI_DynLibManager.h
-  include/MyGUI_FactoryManager.h
-  include/MyGUI_FontManager.h
-  include/MyGUI_Gui.h
-  include/MyGUI_InputManager.h
-  include/MyGUI_LanguageManager.h
-  include/MyGUI_LayerManager.h
-  include/MyGUI_LayoutManager.h
-  include/MyGUI_PluginManager.h
-  include/MyGUI_PointerManager.h
-  include/MyGUI_RenderManager.h
-  include/MyGUI_ResourceManager.h
-  include/MyGUI_SkinManager.h
-  include/MyGUI_SubWidgetManager.h
-  include/MyGUI_WidgetManager.h
-)
-set (SOURCE_FILES
-  src/MyGUI_Button.cpp
-  src/MyGUI_Canvas.cpp
-  src/MyGUI_ComboBox.cpp
-  src/MyGUI_DDContainer.cpp
-  src/MyGUI_Edit.cpp
-  src/MyGUI_HScroll.cpp
-  src/MyGUI_ItemBox.cpp
-  src/MyGUI_List.cpp
-  src/MyGUI_ListBox.cpp
-  src/MyGUI_ListCtrl.cpp
-  src/MyGUI_MenuBar.cpp
-  src/MyGUI_MenuCtrl.cpp
-  src/MyGUI_MenuItem.cpp
-  src/MyGUI_Message.cpp
-  src/MyGUI_MultiList.cpp
-  src/MyGUI_PopupMenu.cpp
-  src/MyGUI_Progress.cpp
-  src/MyGUI_ScrollView.cpp
-  src/MyGUI_StaticImage.cpp
-  src/MyGUI_StaticText.cpp
-  src/MyGUI_Tab.cpp
-  src/MyGUI_TabItem.cpp
-  src/MyGUI_VScroll.cpp
-  src/MyGUI_Widget.cpp
-  src/MyGUI_Window.cpp
-  src/MyGUI_EditText.cpp
-  src/MyGUI_MainSkin.cpp
-  src/MyGUI_RawRect.cpp
-  src/MyGUI_RotatingSkin.cpp
-  src/MyGUI_SimpleText.cpp
-  src/MyGUI_SubSkin.cpp
-  src/MyGUI_TileRect.cpp
-  src/MyGUI_LayerItem.cpp
-  src/MyGUI_LayerNode.cpp
-  src/MyGUI_OverlappedLayer.cpp
-  src/MyGUI_RenderItem.cpp
-  src/MyGUI_SharedLayer.cpp
-  src/MyGUI_SharedLayerNode.cpp
-  src/MyGUI_ActionController.cpp
-  src/MyGUI_ControllerEdgeHide.cpp
-  src/MyGUI_ControllerFadeAlpha.cpp
-  src/MyGUI_ControllerPosition.cpp
-  src/MyGUI_Exception.cpp
-  src/MyGUI_Precompiled.cpp
-  src/MyGUI_IWidgetCreator.cpp
-  src/MyGUI_ScrollViewBase.cpp
-  src/MyGUI_ResourceImageSet.cpp
-  src/MyGUI_ResourceImageSetPointer.cpp
-  src/MyGUI_ResourceManualFont.cpp
-  src/MyGUI_ResourceManualPointer.cpp
-  src/MyGUI_ResourceSkin.cpp
-  src/MyGUI_ResourceTrueTypeFont.cpp
-  src/MyGUI_MaskPickInfo.cpp
-  src/MyGUI_Any.cpp
-  src/MyGUI_Colour.cpp
-  src/MyGUI_ClipboardManager.cpp
-  src/MyGUI_ControllerManager.cpp
-  src/MyGUI_DataManager.cpp
-  src/MyGUI_DynLibManager.cpp
-  src/MyGUI_FactoryManager.cpp
-  src/MyGUI_FontManager.cpp
-  src/MyGUI_Gui.cpp
-  src/MyGUI_InputManager.cpp
-  src/MyGUI_LanguageManager.cpp
-  src/MyGUI_LayerManager.cpp
-  src/MyGUI_LayoutManager.cpp
-  src/MyGUI_PluginManager.cpp
-  src/MyGUI_PointerManager.cpp
-  src/MyGUI_RenderManager.cpp
-  src/MyGUI_ResourceManager.cpp
-  src/MyGUI_SkinManager.cpp
-  src/MyGUI_SubWidgetManager.cpp
-  src/MyGUI_WidgetManager.cpp
-  src/MyGUI_DataFileStream.cpp
-  src/MyGUI_DataStream.cpp
-  src/MyGUI_DynLib.cpp
-  src/MyGUI_Guid.cpp
-  src/MyGUI_RenderOut.cpp
-  src/MyGUI_TextIterator.cpp
-  src/MyGUI_TextureUtility.cpp
-  src/MyGUI_Timer.cpp
-  src/MyGUI_XmlDocument.cpp
-  src/MyGUI_LogManager.cpp
-  src/MyGUI_LogStream.cpp
-)
-SOURCE_GROUP("Source Files\\Widget\\Widget" FILES
-  src/MyGUI_Button.cpp
-  src/MyGUI_Canvas.cpp
-  src/MyGUI_ComboBox.cpp
-  src/MyGUI_DDContainer.cpp
-  src/MyGUI_Edit.cpp
-  src/MyGUI_HScroll.cpp
-  src/MyGUI_ItemBox.cpp
-  src/MyGUI_List.cpp
-  src/MyGUI_ListBox.cpp
-  src/MyGUI_ListCtrl.cpp
-  src/MyGUI_MenuBar.cpp
-  src/MyGUI_MenuCtrl.cpp
-  src/MyGUI_MenuItem.cpp
-  src/MyGUI_Message.cpp
-  src/MyGUI_MultiList.cpp
-  src/MyGUI_PopupMenu.cpp
-  src/MyGUI_Progress.cpp
-  src/MyGUI_ScrollView.cpp
-  src/MyGUI_StaticImage.cpp
-  src/MyGUI_StaticText.cpp
-  src/MyGUI_Tab.cpp
-  src/MyGUI_TabItem.cpp
-  src/MyGUI_VScroll.cpp
-  src/MyGUI_Widget.cpp
-  src/MyGUI_Window.cpp
-)
-SOURCE_GROUP("Source Files\\Widget" FILES
-)
-SOURCE_GROUP("Source Files\\Core\\SubWidget" FILES
-  src/MyGUI_EditText.cpp
-  src/MyGUI_MainSkin.cpp
-  src/MyGUI_RawRect.cpp
-  src/MyGUI_RotatingSkin.cpp
-  src/MyGUI_SimpleText.cpp
-  src/MyGUI_SubSkin.cpp
-  src/MyGUI_TileRect.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\LayerItem" FILES
-  src/MyGUI_LayerItem.cpp
-  src/MyGUI_LayerNode.cpp
-  src/MyGUI_OverlappedLayer.cpp
-  src/MyGUI_RenderItem.cpp
-  src/MyGUI_SharedLayer.cpp
-  src/MyGUI_SharedLayerNode.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Controller" FILES
-  src/MyGUI_ActionController.cpp
-  src/MyGUI_ControllerEdgeHide.cpp
-  src/MyGUI_ControllerFadeAlpha.cpp
-  src/MyGUI_ControllerPosition.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Common\\Interfaces" FILES
-  src/MyGUI_IWidgetCreator.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Common\\Base" FILES
-  src/MyGUI_ScrollViewBase.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Common" FILES
-  src/MyGUI_Exception.cpp
-  src/MyGUI_Precompiled.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Resource\\Data" FILES
-  src/MyGUI_MaskPickInfo.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Resource" FILES
-  src/MyGUI_ResourceImageSet.cpp
-  src/MyGUI_ResourceImageSetPointer.cpp
-  src/MyGUI_ResourceManualFont.cpp
-  src/MyGUI_ResourceManualPointer.cpp
-  src/MyGUI_ResourceSkin.cpp
-  src/MyGUI_ResourceTrueTypeFont.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Types" FILES
-  src/MyGUI_Any.cpp
-  src/MyGUI_Colour.cpp
-)
-SOURCE_GROUP("Source Files\\Core\\Manager" FILES
-  src/MyGUI_ClipboardManager.cpp
-  src/MyGUI_ControllerManager.cpp
-  src/MyGUI_DataManager.cpp
-  src/MyGUI_DynLibManager.cpp
-  src/MyGUI_FactoryManager.cpp
-  src/MyGUI_FontManager.cpp
-  src/MyGUI_Gui.cpp
-  src/MyGUI_InputManager.cpp
-  src/MyGUI_LanguageManager.cpp
-  src/MyGUI_LayerManager.cpp
-  src/MyGUI_LayoutManager.cpp
-  src/MyGUI_PluginManager.cpp
-  src/MyGUI_PointerManager.cpp
-  src/MyGUI_RenderManager.cpp
-  src/MyGUI_ResourceManager.cpp
-  src/MyGUI_SkinManager.cpp
-  src/MyGUI_SubWidgetManager.cpp
-  src/MyGUI_WidgetManager.cpp
-)
-SOURCE_GROUP("Source Files\\Core" FILES
-)
-SOURCE_GROUP("Source Files\\Utility\\Logging" FILES
-  src/MyGUI_LogManager.cpp
-  src/MyGUI_LogStream.cpp
-)
-SOURCE_GROUP("Source Files\\Utility" FILES
-  src/MyGUI_DataFileStream.cpp
-  src/MyGUI_DataStream.cpp
-  src/MyGUI_DynLib.cpp
-  src/MyGUI_Guid.cpp
-  src/MyGUI_RenderOut.cpp
-  src/MyGUI_TextIterator.cpp
-  src/MyGUI_TextureUtility.cpp
-  src/MyGUI_Timer.cpp
-  src/MyGUI_XmlDocument.cpp
-)
-SOURCE_GROUP("Source Files" FILES
-)
-SOURCE_GROUP("Header Files\\Widget\\Types" FILES
-  include/MyGUI_DDItemInfo.h
-  include/MyGUI_IBItemInfo.h
-  include/MyGUI_MenuItemType.h
-  include/MyGUI_MessageStyle.h
-  include/MyGUI_WidgetToolTip.h
-)
-SOURCE_GROUP("Header Files\\Widget\\Widget" FILES
-  include/MyGUI_Button.h
-  include/MyGUI_Canvas.h
-  include/MyGUI_ComboBox.h
-  include/MyGUI_DDContainer.h
-  include/MyGUI_Edit.h
-  include/MyGUI_HScroll.h
-  include/MyGUI_ItemBox.h
-  include/MyGUI_List.h
-  include/MyGUI_ListBox.h
-  include/MyGUI_ListCtrl.h
-  include/MyGUI_MenuBar.h
-  include/MyGUI_MenuCtrl.h
-  include/MyGUI_MenuItem.h
-  include/MyGUI_Message.h
-  include/MyGUI_MultiList.h
-  include/MyGUI_PopupMenu.h
-  include/MyGUI_Progress.h
-  include/MyGUI_ScrollView.h
-  include/MyGUI_StaticImage.h
-  include/MyGUI_StaticText.h
-  include/MyGUI_Tab.h
-  include/MyGUI_TabItem.h
-  include/MyGUI_VScroll.h
-  include/MyGUI_Widget.h
-  include/MyGUI_Window.h
-)
-SOURCE_GROUP("Header Files\\Widget\\Interfaces" FILES
-  include/MyGUI_IWidgetFactory.h
-)
-SOURCE_GROUP("Header Files\\Widget" FILES
-)
-SOURCE_GROUP("Header Files\\Utility\\Logging" FILES
-  include/MyGUI_LogManager.h
-  include/MyGUI_LogStream.h
-)
-SOURCE_GROUP("Header Files\\Utility" FILES
-  include/MyGUI_Bitwise.h
-  include/MyGUI_CoordConverter.h
-  include/MyGUI_DataFileStream.h
-  include/MyGUI_DataStream.h
-  include/MyGUI_Delegate.h
-  include/MyGUI_DelegateImplement.h
-  include/MyGUI_DynLib.h
-  include/MyGUI_Enumerator.h
-  include/MyGUI_EventPair.h
-  include/MyGUI_Guid.h
-  include/MyGUI_RenderOut.h
-  include/MyGUI_TextChangeHistory.h
-  include/MyGUI_TextIterator.h
-  include/MyGUI_TextureUtility.h
-  include/MyGUI_TextView.h
-  include/MyGUI_Timer.h
-  include/MyGUI_UString.h
-  include/MyGUI_Utility.h
-  include/MyGUI_WidgetTranslate.h
-  include/MyGUI_XmlDocument.h
-)
-SOURCE_GROUP("Header Files\\Core\\Common\\Interfaces" FILES
-  include/MyGUI_ICroppedRectangle.h
-  include/MyGUI_IDataStream.h
-  include/MyGUI_Instance.h
-  include/MyGUI_IObject.h
-  include/MyGUI_ISerializable.h
-  include/MyGUI_ITexture.h
-  include/MyGUI_IUnlinkWidget.h
-  include/MyGUI_IVertexBuffer.h
-  include/MyGUI_IWidgetCreator.h
-  include/MyGUI_Plugin.h
-  include/MyGUI_RTTI.h
-)
-SOURCE_GROUP("Header Files\\Core\\Common\\Base" FILES
-  include/MyGUI_BiIndexBase.h
-  include/MyGUI_ScrollViewBase.h
-  include/MyGUI_WidgetEvent.h
-  include/MyGUI_WidgetUserData.h
-)
-SOURCE_GROUP("Header Files\\Core\\Common" FILES
-  include/MyGUI.h
-  include/MyGUI_CastWidget.h
-  include/MyGUI_Common.h
-  include/MyGUI_Diagnostic.h
-  include/MyGUI_Exception.h
-  include/MyGUI_GenericFactory.h
-  include/MyGUI_Macros.h
-  include/MyGUI_Platform.h
-  include/MyGUI_Precompiled.h
-  include/MyGUI_Prerequest.h
-  include/MyGUI_RenderFormat.h
-  include/MyGUI_ResourceHolder.h
-  include/MyGUI_WidgetDefines.h
-)
-SOURCE_GROUP("Header Files\\Core\\SubWidget\\Interfaces" FILES
-  include/MyGUI_IStateInfo.h
-  include/MyGUI_ISubWidget.h
-  include/MyGUI_ISubWidgetRect.h
-  include/MyGUI_ISubWidgetText.h
-)
-SOURCE_GROUP("Header Files\\Core\\SubWidget" FILES
-  include/MyGUI_EditText.h
-  include/MyGUI_MainSkin.h
-  include/MyGUI_RawRect.h
-  include/MyGUI_RotatingSkin.h
-  include/MyGUI_SimpleText.h
-  include/MyGUI_SubSkin.h
-  include/MyGUI_TileRect.h
-)
-SOURCE_GROUP("Header Files\\Core\\LayerItem\\Interfaces" FILES
-  include/MyGUI_ILayer.h
-  include/MyGUI_ILayerItem.h
-  include/MyGUI_ILayerNode.h
-  include/MyGUI_IRenderTarget.h
-)
-SOURCE_GROUP("Header Files\\Core\\LayerItem" FILES
-  include/MyGUI_LayerItem.h
-  include/MyGUI_LayerNode.h
-  include/MyGUI_OverlappedLayer.h
-  include/MyGUI_RenderItem.h
-  include/MyGUI_SharedLayer.h
-  include/MyGUI_SharedLayerNode.h
-)
-SOURCE_GROUP("Header Files\\Core\\Controller" FILES
-  include/MyGUI_ActionController.h
-  include/MyGUI_ControllerEdgeHide.h
-  include/MyGUI_ControllerFadeAlpha.h
-  include/MyGUI_ControllerItem.h
-  include/MyGUI_ControllerPosition.h
-)
-SOURCE_GROUP("Header Files\\Core\\Resource\\Interface" FILES
-  include/MyGUI_IFont.h
-  include/MyGUI_IPointer.h
-  include/MyGUI_IResource.h
-)
-SOURCE_GROUP("Header Files\\Core\\Resource\\Data" FILES
-  include/MyGUI_ChildSkinInfo.h
-  include/MyGUI_FontData.h
-  include/MyGUI_MaskPickInfo.h
-  include/MyGUI_SubWidgetBinding.h
-  include/MyGUI_SubWidgetInfo.h
-)
-SOURCE_GROUP("Header Files\\Core\\Resource" FILES
-  include/MyGUI_ResourceImageSet.h
-  include/MyGUI_ResourceImageSetPointer.h
-  include/MyGUI_ResourceManualFont.h
-  include/MyGUI_ResourceManualPointer.h
-  include/MyGUI_ResourceSkin.h
-  include/MyGUI_ResourceTrueTypeFont.h
-)
-SOURCE_GROUP("Header Files\\Core\\Types" FILES
-  include/MyGUI_Align.h
-  include/MyGUI_Any.h
-  include/MyGUI_Colour.h
-  include/MyGUI_CommonStateInfo.h
-  include/MyGUI_ImageInfo.h
-  include/MyGUI_InputDefine.h
-  include/MyGUI_RenderTargetInfo.h
-  include/MyGUI_TCoord.h
-  include/MyGUI_TPoint.h
-  include/MyGUI_TRect.h
-  include/MyGUI_TSize.h
-  include/MyGUI_Types.h
-  include/MyGUI_Version.h
-  include/MyGUI_VertexData.h
-  include/MyGUI_WidgetStyle.h
-)
-SOURCE_GROUP("Header Files\\Core\\Manager" FILES
-  include/MyGUI_ClipboardManager.h
-  include/MyGUI_ControllerManager.h
-  include/MyGUI_DataManager.h
-  include/MyGUI_DynLibManager.h
-  include/MyGUI_FactoryManager.h
-  include/MyGUI_FontManager.h
-  include/MyGUI_Gui.h
-  include/MyGUI_InputManager.h
-  include/MyGUI_LanguageManager.h
-  include/MyGUI_LayerManager.h
-  include/MyGUI_LayoutManager.h
-  include/MyGUI_PluginManager.h
-  include/MyGUI_PointerManager.h
-  include/MyGUI_RenderManager.h
-  include/MyGUI_ResourceManager.h
-  include/MyGUI_SkinManager.h
-  include/MyGUI_SubWidgetManager.h
-  include/MyGUI_WidgetManager.h
-)
-SOURCE_GROUP("Header Files\\Core" FILES
-)
-SOURCE_GROUP("Header Files" FILES
-  include/MyGUI_Allocator.h
-  include/MyGUI_CustomAllocator.h
-)
-SOURCE_GROUP("" FILES
-  CMakeLists.txt
-)

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI.h

@@ -1,92 +0,0 @@
-/*!
-	@file
-	@author		Georgiy Evmenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_H__
-#define __MYGUI_H__
-
-#include "MyGUI_Gui.h"
-
-#include "MyGUI_Button.h"
-#include "MyGUI_ComboBox.h"
-#include "MyGUI_Edit.h"
-#include "MyGUI_HScroll.h"
-#include "MyGUI_List.h"
-#include "MyGUI_StaticText.h"
-#include "MyGUI_StaticImage.h"
-#include "MyGUI_Tab.h"
-#include "MyGUI_TabItem.h"
-#include "MyGUI_VScroll.h"
-#include "MyGUI_Window.h"
-#include "MyGUI_Progress.h"
-#include "MyGUI_Message.h"
-#include "MyGUI_ItemBox.h"
-#include "MyGUI_MultiList.h"
-#include "MyGUI_MenuCtrl.h"
-#include "MyGUI_MenuItem.h"
-#include "MyGUI_PopupMenu.h"
-#include "MyGUI_MenuBar.h"
-#include "MyGUI_ScrollView.h"
-#include "MyGUI_DDContainer.h"
-#include "MyGUI_Canvas.h"
-#include "MyGUI_ListCtrl.h"
-#include "MyGUI_ListBox.h"
-
-#include "MyGUI_InputManager.h"
-#include "MyGUI_SubWidgetManager.h"
-#include "MyGUI_ClipboardManager.h"
-#include "MyGUI_LayerManager.h"
-#include "MyGUI_LogManager.h"
-#include "MyGUI_SkinManager.h"
-#include "MyGUI_WidgetManager.h"
-#include "MyGUI_LayoutManager.h"
-#include "MyGUI_FontManager.h"
-#include "MyGUI_PointerManager.h"
-#include "MyGUI_PluginManager.h"
-#include "MyGUI_DynLibManager.h"
-#include "MyGUI_ControllerManager.h"
-#include "MyGUI_LanguageManager.h"
-#include "MyGUI_ResourceManager.h"
-#include "MyGUI_RenderManager.h"
-#include "MyGUI_DataManager.h"
-#include "MyGUI_FactoryManager.h"
-
-#include "MyGUI_ActionController.h"
-#include "MyGUI_ControllerEdgeHide.h"
-#include "MyGUI_ControllerFadeAlpha.h"
-#include "MyGUI_ControllerPosition.h"
-#include "MyGUI_CoordConverter.h"
-#include "MyGUI_IResource.h"
-#include "MyGUI_CastWidget.h"
-#include "MyGUI_Any.h"
-#include "MyGUI_MenuItemType.h"
-#include "MyGUI_Version.h"
-#include "MyGUI_XmlDocument.h"
-#include "MyGUI_WidgetStyle.h"
-#include "MyGUI_IObject.h"
-#include "MyGUI_ISerializable.h"
-#include "MyGUI_RenderOut.h"
-
-#include "MyGUI_RawRect.h"
-#include "MyGUI_RotatingSkin.h"
-#include "MyGUI_TextureUtility.h"
-
-#endif // __MYGUI_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ActionController.h

@@ -1,75 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ACTION_CONTROLLER_H__
-#define __MYGUI_ACTION_CONTROLLER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-#include <math.h>
-
-namespace MyGUI
-{
-
-	namespace action
-	{
-
-		/** Function used for hiding widget with one of controller event */
-		void MYGUI_EXPORT actionWidgetHide(Widget* _widget);
-
-		/** Function used for showing widget with one of controller event */
-		void MYGUI_EXPORT actionWidgetShow(Widget* _widget);
-
-		/** Function used for destroying widget with one of controller event */
-		void MYGUI_EXPORT actionWidgetDestroy(Widget* _widget);
-
-		/** Function for ControllerPosition per frame action : Move with constant speed */
-		void MYGUI_EXPORT linearMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _k);
-
-		/** Function for ControllerPosition per frame action : Move with accelerated speed
-			if N == 10 then this function is same as linearMoveFunction
-			if N > 10 speed will be increasing
-			if N < 10 speed will be decreasing
-		*/
-		template <int N>
-		inline void acceleratedMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time)
-		{
-			float k = (float)pow (_current_time, N/10.f /*3 by default as Accelerated and 0.4 by default as Slowed*/);
-			linearMoveFunction(_startRect, _destRect, _result, k);
-		}
-
-		/** Function for ControllerPosition per frame action : Move with accelerated speed a bit farther than necessary and then return it back */
-		template <int N>
-		inline void jumpMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time)
-		{
-			float k = pow (_current_time, 2) * (-2 - N/10.f) + _current_time * (3 + N/10.f);
-			linearMoveFunction(_startRect, _destRect, _result, k);
-		}
-
-		/** Function for ControllerPosition per frame action : Start with zero speed increasing half time and then decreasing to zero */
-		void MYGUI_EXPORT inertionalMoveFunction(const IntCoord& _startRect, const IntCoord& _destRect, IntCoord& _result, float _current_time);
-
-	} // namespace action
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ACTION_CONTROLLER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Align.h

@@ -1,202 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		08/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ALIGN_H__
-#define __MYGUI_ALIGN_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Macros.h"
-#include "MyGUI_Diagnostic.h"
-#include <map>
-
-namespace MyGUI
-{
-
-	struct MYGUI_EXPORT Align
-	{
-		enum Enum
-		{
-			HCenter = MYGUI_FLAG_NONE, /**< center horizontally */
-			VCenter = MYGUI_FLAG_NONE, /**< center vertically */
-			Center = HCenter | VCenter, /**< center in the dead center */
-
-			Left = MYGUI_FLAG(1), /**< value from the left (and center vertically) */
-			Right = MYGUI_FLAG(2), /**< value from the right (and center vertically) */
-			HStretch = Left | Right, /**< stretch horizontally proportionate to parent window (and center vertically) */
-
-			Top = MYGUI_FLAG(3), /**< value from the top (and center horizontally) */
-			Bottom = MYGUI_FLAG(4), /**< value from the bottom (and center horizontally) */
-			VStretch = Top | Bottom, /**< stretch vertically proportionate to parent window (and center horizontally) */
-
-			Stretch = HStretch | VStretch, /**< stretch proportionate to parent window */
-			Default = Left | Top, /**< default value (value from left and top) */
-
-			HRelative = MYGUI_FLAG(5),
-			VRelative = MYGUI_FLAG(6),
-			Relative = HRelative | VRelative
-		};
-
-		Align(Enum _value = Default) : value(_value) { }
-
-		bool isHCenter() const { return HCenter == (value & ((int)HStretch | (int)HRelative)); }
-		bool isVCenter() const { return VCenter == (value & ((int)VStretch | (int)VRelative)); }
-		bool isCenter() const { return Center == (value & ((int)Stretch | (int)Relative)); }
-
-		bool isLeft() const { return Left == (value & ((int)HStretch | (int)HRelative)); }
-		bool isRight() const { return Right == (value & ((int)HStretch | (int)HRelative)); }
-		bool isHStretch() const { return HStretch == (value & ((int)HStretch | (int)HRelative)); }
-
-		bool isTop() const { return Top == (value & ((int)VStretch | (int)VRelative)); }
-		bool isBottom() const { return (Bottom == (value & ((int)VStretch | (int)VRelative))); }
-		bool isVStretch() const { return (VStretch == (value & ((int)VStretch | (int)VRelative))); }
-
-		bool isStretch() const { return (Stretch == (value & ((int)Stretch | (int)Relative))); }
-		bool isDefault() const { return (Default == (value & ((int)Stretch | (int)Relative))); }
-
-		bool isHRelative() const { return HRelative == (value & (int)HRelative); }
-		bool isVRelative() const { return VRelative == (value & (int)VRelative); }
-		bool isRelative() const { return Relative == (value & (int)Relative); }
-
-		Align& operator |= (Align const& _other) { value = Enum(int(value) | int(_other.value)); return *this; }
-		friend Align operator | (Enum const& a, Enum const& b) { return Align(Enum(int(a) | int(b))); }
-		friend Align operator | (Align const& a, Align const& b) { return Align(Enum(int(a.value) | int(b.value))); }
-
-		friend bool operator == (Align const& a, Align const& b) { return a.value == b.value; }
-		friend bool operator != (Align const& a, Align const& b) { return a.value != b.value; }
-
-		typedef std::map<std::string, int> MapAlign;
-
-		static Align parse(const std::string& _value)
-		{
-			Align result(Enum(0));
-			const MapAlign& map_names = result.getValueNames();
-			const std::vector<std::string>& vec = utility::split(_value);
-			for (size_t pos=0; pos<vec.size(); pos++)
-			{
-				MapAlign::const_iterator iter = map_names.find(vec[pos]);
-				if (iter != map_names.end())
-				{
-					result.value = Enum(int(result.value) | int(iter->second));
-				}
-			}
-			return result;
-		}
-
-		std::string print() const
-		{
-			std::string result;
-
-			if (value & Left)
-			{
-				if (value & Right) result = "HStretch";
-				else result = "Left";
-			}
-			else if (value & Right) result = "Right";
-			else result = "HCenter";
-
-			if (value & Top)
-			{
-				if (value & Bottom) result += " VStretch";
-				else result += " Top";
-			}
-			else if (value & Bottom) result += " Bottom";
-			else result += " VCenter";
-
-			return result;
-		}
-
-		friend std::ostream& operator << ( std::ostream& _stream, const Align&  _value )
-		{
-			_stream << _value.print();
-			return _stream;
-		}
-
-		friend std::istream& operator >> ( std::istream& _stream, Align&  _value )
-		{
-			_value.value = Enum(0);
-			std::string value;
-			_stream >> value;
-
-			const MapAlign& map_names = _value.getValueNames();
-			MapAlign::const_iterator iter = map_names.find(value);
-			if (iter != map_names.end())
-				_value.value = Enum(int(_value.value) | int(iter->second));
-
-
-			if (!_stream.eof())
-			{
-				std::string value2;
-				_stream >> value2;
-				iter = map_names.find(value2);
-				if (iter != map_names.end())
-					_value.value = Enum(int(_value.value) | int(iter->second));
-			}
-
-			return _stream;
-		}
-
-	private:
-		const MapAlign& getValueNames() const
-		{
-			static MapAlign map_names;
-
-			if (map_names.empty())
-			{
-				// OBSOLETE
-				map_names["ALIGN_HCENTER"] = HCenter;
-				map_names["ALIGN_VCENTER"] = VCenter;
-				map_names["ALIGN_CENTER"] = Center;
-				map_names["ALIGN_LEFT"] = Left;
-				map_names["ALIGN_RIGHT"] = Right;
-				map_names["ALIGN_HSTRETCH"] = HStretch;
-				map_names["ALIGN_TOP"] = Top;
-				map_names["ALIGN_BOTTOM"] = Bottom;
-				map_names["ALIGN_VSTRETCH"] = VStretch;
-				map_names["ALIGN_STRETCH"] = Stretch;
-				map_names["ALIGN_DEFAULT"] = Default;
-
-				MYGUI_REGISTER_VALUE(map_names, HCenter);
-				MYGUI_REGISTER_VALUE(map_names, VCenter);
-				MYGUI_REGISTER_VALUE(map_names, Center);
-				MYGUI_REGISTER_VALUE(map_names, Left);
-				MYGUI_REGISTER_VALUE(map_names, Right);
-				MYGUI_REGISTER_VALUE(map_names, HStretch);
-				MYGUI_REGISTER_VALUE(map_names, Top);
-				MYGUI_REGISTER_VALUE(map_names, Bottom);
-				MYGUI_REGISTER_VALUE(map_names, VStretch);
-				MYGUI_REGISTER_VALUE(map_names, Stretch);
-				MYGUI_REGISTER_VALUE(map_names, Default);
-				MYGUI_REGISTER_VALUE(map_names, HRelative);
-				MYGUI_REGISTER_VALUE(map_names, VRelative);
-				MYGUI_REGISTER_VALUE(map_names, Relative);
-			}
-
-			return map_names;
-		}
-
-	private:
-		Enum value;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ALIGN_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Allocator.h

@@ -1,89 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ALLOCATOR_H__
-#define __MYGUI_ALLOCATOR_H__
-
-#include <memory>
-#include <limits>
-
-namespace MyGUI
-{
-
-	template<typename T>
-	class Allocator
-	{
-	public:
-		//    typedefs
-		typedef T value_type;
-		typedef value_type* pointer;
-		typedef const value_type* const_pointer;
-		typedef value_type& reference;
-		typedef const value_type& const_reference;
-		typedef std::size_t size_type;
-		typedef std::ptrdiff_t difference_type;
-
-	public:
-		//    convert an allocator<T> to allocator<U>
-		template<typename U>
-		struct rebind
-		{
-			typedef Allocator<U> other;
-		};
-
-	public:
-		inline explicit Allocator() { }
-		inline ~Allocator() { }
-		template<typename U>
-		inline explicit Allocator(Allocator<U> const&) { }
-
-		//    address
-		inline pointer address(reference r) { return &r; }
-		inline const_pointer address(const_reference r) { return &r; }
-
-		//    memory allocation
-		inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0)
-		{
-			return reinterpret_cast<pointer>(::operator new (cnt * sizeof (T)));
-		}
-		inline void deallocate(pointer p, size_type)
-		{
-			::operator delete (p);
-		}
-
-		//    size
-		inline size_type max_size() const
-		{
-			return std::numeric_limits<size_type>::max() / sizeof(T);
-		}
-
-		//    construction/destruction
-		inline void construct(pointer p, const T& t) { new (p) T(t); }
-		inline void destroy(pointer p) { p->~T(); }
-
-		inline bool operator==(Allocator const&) { return true; }
-		inline bool operator!=(Allocator const& a) { return !operator==(a); }
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ALLOCATOR_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Any.h

@@ -1,213 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		10/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-// -- Based on boost::any, original copyright information follows --
-// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See at http://www.boost.org/LICENSE_1_0.txt)
-// -- End original copyright --
-
-#ifndef __MYGUI_ANY_H__
-#define __MYGUI_ANY_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Diagnostic.h"
-#include <algorithm>
-#include <typeinfo>
-
-namespace MyGUI
-{
-
-	/** @example "Class Any usage"
-	@code
-	void f()
-	{
-		// RU: тестовый класс, с простыми типами все аналогично
-		// EN: test class, with simple types all is similar
-		struct Data { int value; };
-
-		// RU: экземпляр и инициализация
-		// EN: instance and initialization
-		Data data;
-		data.value = 0xDEAD;
-
-		// RU: создастся копия класса Data
-		// EN: copy of class Data will be created
-		MyGUI::Any any = data;
-		// RU: копия класса Data
-		// EN: copy of class Data
-		Data copy_data = *any.castType<Data>();
-		// RU: теперь value == 0xDEAD
-		// EN: now value == 0xDEAD
-		int value = copy_data.value;
-
-
-		// RU: создастся копия указателя на класс Data
-		// EN: copy of pointer on class Data will be created
-		any = &data;
-		// RU: копия указателя на класс Data и конкретно на объект data
-		// EN: copy of pointer on class Data and on object data
-		Data * copy_ptr = *any.castType<Data*>();
-		// RU: теперь data.value == 0
-		// EN: now value == 0
-		copy_ptr->value = 0;
-
-	}
-	@endcode
-	*/
-
-	class MYGUI_EXPORT Any
-	{
-
-	private:
-		struct AnyEmpty { };
-
-	public:
-		static AnyEmpty Null;
-
-	public:
-		Any() :
-			mContent(nullptr)
-		{
-		}
-
-		template<typename ValueType> Any(const ValueType& value) :
-			mContent(new Holder<ValueType>(value))
-		{
-		}
-
-		Any(const Any::AnyEmpty& value) :
-			mContent(nullptr)
-		{
-		}
-
-		Any(const Any& other) :
-			mContent(other.mContent ? other.mContent->clone() : nullptr)
-		{
-		}
-
-		~Any()
-		{
-			delete mContent;
-		}
-
-		Any& swap(Any& rhs)
-		{
-			std::swap(mContent, rhs.mContent);
-			return *this;
-		}
-
-		template<typename ValueType> Any& operator = (const ValueType& rhs)
-		{
-			Any(rhs).swap(*this);
-			return *this;
-		}
-
-		Any& operator = (const Any::AnyEmpty& rhs)
-		{
-			delete mContent;
-			mContent = nullptr;
-			return *this;
-		}
-
-		Any& operator = (const Any& rhs)
-		{
-			Any(rhs).swap(*this);
-			return *this;
-		}
-
-		bool empty() const
-		{
-			return !mContent;
-		}
-
-		const std::type_info& getType() const
-		{
-			return mContent ? mContent->getType() : typeid(void);
-		}
-
-		template<typename ValueType>
-		ValueType * castType(bool _throw = true) const
-		{
-			if (this->getType() == typeid(ValueType))
-			{
-				return &static_cast<Any::Holder<ValueType> *>(this->mContent)->held;
-			}
-			MYGUI_ASSERT(!_throw, "Bad cast from type '" << getType().name() << "' to '" << typeid(ValueType).name() << "'");
-			return nullptr;
-		}
-
-		void * castUnsafe() const
-		{
-			return mContent ? static_cast<Any::Holder<void *> *>(this->mContent)->held : nullptr;
-		}
-
-	private:
-		class Placeholder
-		{
-		public:
-			virtual ~Placeholder() { }
-
-		public:
-			virtual const std::type_info& getType() const = 0;
-			virtual Placeholder * clone() const = 0;
-
-		};
-
-		template<typename ValueType> class Holder : public Placeholder
-		{
-		public:
-			Holder(const ValueType& value) :
-				held(value)
-			{
-			}
-
-		public:
-			virtual const std::type_info& getType() const
-			{
-				return typeid(ValueType);
-			}
-
-			virtual Placeholder * clone() const
-			{
-				return new Holder(held);
-			}
-
-		public:
-			ValueType held;
-
-		private:
-			Holder& operator=(const Holder &);
-
-		};
-
-
-		private: // representation
-			Placeholder * mContent;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ANY_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_BiIndexBase.h

@@ -1,216 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		10/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_BIINDEX_BASE_H__
-#define __MYGUI_BIINDEX_BASE_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	class BiIndexBase
-	{
-	public:
-		virtual ~BiIndexBase() { }
-	protected:
-
-		size_t getIndexCount() { return mIndexFace.size(); }
-
-		size_t insertItemAt(size_t _index)
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE_INSERT(_index, mIndexFace.size(), "BiIndexBase::insertItemAt");
-				checkIndexes();
-			#endif
-
-			if (_index == MyGUI::ITEM_NONE) _index = mIndexFace.size();
-
-			size_t index;
-
-			if (_index == mIndexFace.size())
-			{
-				// для вставки айтема
-				index = mIndexFace.size();
-
-				mIndexFace.push_back(_index);
-				mIndexBack.push_back(_index);
-			}
-			else
-			{
-				// для вставки айтема
-				index = mIndexFace[_index];
-
-				size_t count = mIndexFace.size();
-				for (size_t pos=0; pos<count; ++pos)
-				{
-					if (mIndexFace[pos] >= index) mIndexFace[pos]++;
-				}
-				mIndexFace.insert(mIndexFace.begin() + _index, index);
-
-				count ++;
-				mIndexBack.push_back(0);
-				for (size_t pos=0; pos<count; ++pos)
-				{
-					mIndexBack[mIndexFace[pos]] = pos;
-				}
-			}
-
-			#if MYGUI_DEBUG_MODE == 1
-				checkIndexes();
-			#endif
-
-			return index;
-		}
-
-		size_t removeItemAt(size_t _index)
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE(_index, mIndexFace.size(), "BiIndexBase::removeItemAt");
-				checkIndexes();
-			#endif
-
-			// для удаления айтема
-			size_t index = mIndexFace[_index];
-
-			mIndexFace.erase(mIndexFace.begin() + _index);
-			mIndexBack.pop_back();
-
-			size_t count = mIndexFace.size();
-			for (size_t pos=0; pos<count; ++pos)
-			{
-				if (mIndexFace[pos] > index) mIndexFace[pos]--;
-				mIndexBack[mIndexFace[pos]] = pos;
-			}
-
-			#if MYGUI_DEBUG_MODE == 1
-				checkIndexes();
-			#endif
-
-			return index;
-		}
-
-		void removeAllItems()
-		{
-			mIndexFace.clear();
-			mIndexBack.clear();
-		}
-
-		// на входе индексы пользователя, на выходе реальные индексы
-		size_t convertToBack(size_t _index) const
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE_AND_NONE(_index, mIndexFace.size(), "BiIndexBase::convertToBack");
-			#endif
-			return _index == ITEM_NONE ? ITEM_NONE : mIndexFace[_index];
-		}
-
-		// на входе индексы реальные, на выходе, то что видит пользователь
-		size_t convertToFace(size_t _index) const
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE_AND_NONE(_index, mIndexFace.size(), "BiIndexBase::convertToFace");
-			#endif
-			return _index == ITEM_NONE ? ITEM_NONE : mIndexBack[_index];
-		}
-
-		// меняет местами два индекса, индексы со стороны пользователя
-		void swapItemsFaceAt(size_t _index1, size_t _index2)
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE(_index1, mIndexFace.size(), "BiIndexBase::swapItemsFaceAt");
-				MYGUI_ASSERT_RANGE(_index2, mIndexFace.size(), "BiIndexBase::swapItemsFaceAt");
-			#endif
-
-			std::swap(mIndexFace[_index1], mIndexFace[_index2]);
-			std::swap(mIndexBack[mIndexFace[_index1]], mIndexBack[mIndexFace[_index2]]);
-		}
-
-		// меняет местами два индекса, индексы со сторонны данных
-		void swapItemsBackAt(size_t _index1, size_t _index2)
-		{
-			#if MYGUI_DEBUG_MODE == 1
-				MYGUI_ASSERT_RANGE(_index1, mIndexFace.size(), "BiIndexBase::swapItemsBackAt");
-				MYGUI_ASSERT_RANGE(_index2, mIndexFace.size(), "BiIndexBase::swapItemsBackAt");
-			#endif
-
-			std::swap(mIndexBack[_index1], mIndexBack[_index2]);
-			std::swap(mIndexFace[mIndexBack[_index1]], mIndexFace[mIndexBack[_index2]]);
-		}
-
-		#if MYGUI_DEBUG_MODE == 1
-
-		void checkIndexes()
-		{
-			assert(mIndexFace.size() == mIndexBack.size());
-
-			// проверяем на уникальность каждого индекса в маппинге
-			std::vector<bool> vec;
-			size_t count = mIndexFace.size();
-
-			vec.reserve(count);
-			for (size_t pos=0; pos<count; ++pos) vec.push_back(false);
-
-			for (size_t pos=0; pos<count; ++pos)
-			{
-				// максимум
-				size_t index = mIndexBack[pos];
-				if (index >= count) throw new std::exception();
-
-				// максимум
-				index = mIndexFace[pos];
-				if (index >= count) throw new std::exception();
-
-				if (vec[index]) throw new std::exception();
-				vec[index] = true;
-			}
-
-			for (size_t pos=0; pos<count; ++pos)
-			{
-				if (!vec[pos]) throw new std::exception();
-			}
-
-			// проверяем на взаимоссылаемость индексов
-			for (size_t pos=0; pos<count; ++pos)
-			{
-				size_t index = mIndexFace[pos];
-				if (mIndexBack[index] != pos) throw new std::exception();
-			}
-		}
-
-		#endif
-
-	private:
-		typedef std::vector<size_t> VectorSizeT;
-
-		// маппинг с индексов, которые видны наружу
-		// на индексы которые реально используются данными
-		VectorSizeT mIndexFace;
-
-		// маппинг с индексов, которые используют данные
-		// на индексы которые виндны наружу
-		VectorSizeT mIndexBack;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_BIINDEX_BASE_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Bitwise.h

@@ -1,78 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		06/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_BITWISE_H__
-#define __MYGUI_BITWISE_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	class Bitwise
-	{
-	public:
-		/** Returns the closest power-of-two number greater or equal to value.
-		*/
-		template<typename Type>
-		static MYGUI_FORCEINLINE Type firstPO2From(Type _value)
-		{
-			--_value;
-			_value |= _value >> 16;
-			_value |= _value >> 8;
-			_value |= _value >> 4;
-			_value |= _value >> 2;
-			_value |= _value >> 1;
-			++_value;
-			return _value;
-		}
-
-		/** Determines whether the number is power-of-two or not. */
-		template<typename Type>
-		static MYGUI_FORCEINLINE bool isPO2(Type _value)
-		{
-			return (_value & (_value-1)) == 0;
-		}
-
-		/** Returns the number of bits a pattern must be shifted right by to
-		remove right-hand zeros.
-		*/
-		template<typename Type>
-		static MYGUI_FORCEINLINE size_t getBitShift(Type _mask)
-		{
-			if (_mask == 0)
-				return 0;
-
-			size_t result = 0;
-			while ((_mask & 1) == 0)
-			{
-				++result;
-				_mask >>= 1;
-			}
-			return result;
-		}
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_BITWISE_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Button.h

@@ -1,111 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_BUTTON_H__
-#define __MYGUI_BUTTON_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_StaticText.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT Button :
-		public StaticText
-	{
-		MYGUI_RTTI_DERIVED( Button )
-
-	public:
-		Button();
-
-		//! OLD Set button check state
-		void setButtonPressed(bool _value) { setStateCheck(_value); }
-		//! OLD Get buton check
-		bool getButtonPressed() { return getStateCheck(); }
-
-		//! Set button check state
-		void setStateCheck(bool _value);
-
-		//! Get buton check
-		bool getStateCheck() { return mIsStateCheck; }
-
-		//! Set image index (image should be defined in skin)
-		void setImageIndex(size_t _value);
-		//! Get image index
-		size_t getImageIndex();
-
-		/** Enable or disable Image mode\n
-			Image mode: when button state changed Image on button also change it's picture.\n
-			Disabled (false) by default.
-		*/
-		void setModeImage(bool _value);
-		/** Get Image mode flag */
-		bool getModeImage() { return mModeImage; }
-
-		/** Get pointer to glyph image for this button (if it exist in button skin) */
-		StaticImage* getStaticImage() { return mImage; }
-
-		/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	/*internal:*/
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-		void _setMouseFocus(bool _focus);
-
-	protected:
-		virtual ~Button();
-
-		virtual void baseChangeWidgetSkin(ResourceSkin* _info);
-
-		virtual void onMouseLostFocus(Widget* _new);
-		virtual void onMouseSetFocus(Widget* _old);
-		virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
-		virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
-
-		virtual void baseUpdateEnable();
-
-		bool _setState(const std::string& _value);
-		void setImageResource(const std::string& _name);
-
-	private:
-		void updateButtonState();
-
-		void shutdownWidgetSkin();
-		void initialiseWidgetSkin(ResourceSkin* _info);
-
-	private:
-		// нажата ли кнопка
-		bool mIsMousePressed;
-		// в фокусе ли кнопка
-		bool mIsMouseFocus;
-		// статус кнопки нажата или нет
-		bool mIsStateCheck;
-
-		StaticImage* mImage;
-		bool mModeImage;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_BUTTON_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Canvas.h

@@ -1,246 +0,0 @@
-/*!
-	@file
-	@author		Alexander Ptakhin
-	@date		01/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CANVAS_H__
-#define __MYGUI_CANVAS_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Widget.h"
-#include "MyGUI_ITexture.h"
-
-namespace MyGUI
-{
-
-	/**
-	 * Widget wrapper over Texture - shows the texture.
-	 * Implemented: resizing of texture (see TextureResizeMode); recovery after lossing device;
-	 */
-	class MYGUI_EXPORT Canvas :
-		public Widget,
-		public ITextureInvalidateListener
-	{
-		MYGUI_RTTI_DERIVED( Canvas )
-
-	public:
-		Canvas();
-
-		struct Event
-		{
-			Event( bool _textureChanged, bool _widgetResized, bool _requested ) :
-				textureChanged( _textureChanged ),
-				widgetResized( _widgetResized ),
-				requested( _requested )
-			{
-			}
-
-			bool textureChanged;
-			bool widgetResized;
-
-			/// This update was caused by calling updateTexture();
-			bool requested;
-		};
-
-		typedef delegates::CDelegate1<Canvas*> EventInfo_Canvas;
-		typedef delegates::CDelegate2<Canvas*, Event> EventInfo_CanvasEvent;
-
-		//FIXME
-		/**
-			Available resize and view modes of texture
-			@remarks PT - Power of Two (size)
-		*/
-		enum TextureResizeMode
-		{
-			//
-			TRM_PT_CONST_SIZE, /// Texture doesn't resizes and fills all widget space
-			TRM_PT_VIEW_REQUESTED, /// You can view all pixels of texture, texture cropped by sizes of widget
-			TRM_PT_VIEW_ALL /// Texture resizes and fills all widget space
-		};
-
-	public:
-
-		/// Creates texture
-		void createTexture( TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
-
-		/// Creates texture
-		void createTexture( int _width, int _height, TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
-
-		/// Creates texture
-		void createTexture( const IntSize& _size, TextureResizeMode _resizeMode, TextureUsage _usage = getDefaultTextureUsage(), PixelFormat _format = getDefaultTextureFormat() );
-
-		/// Destroys texture
-		void destroyTexture();
-
-		/// Call user delegate update and removes old texture if it isn't original.
-		void updateTexture();
-
-		/// Locks hardware pixel buffer.
-		void* lock(TextureUsage _usage = TextureUsage::Write);
-
-		/// Unlocks hardware pixel buffer.
-		void unlock();
-
-		/// Checks lockness of hardware _pixel buffer.
-		bool isLocked() const { return mTexture->isLocked(); }
-
-		/// Returns real width of texture.
-		int getTextureRealWidth() const { return (int) mTexture->getWidth(); }
-
-		/// Returns real height of texture.
-		int getTextureRealHeight() const { return (int) mTexture->getHeight(); }
-
-		/// Returns real _size of texture.
-		IntSize getTextureRealSize() const { return IntSize( getTextureRealWidth(), getTextureRealHeight() ); }
-
-		/// Returns needed width while creating texture.
-		int getTextureSrcWidth() const { return mReqTexSize.width; }
-
-		/// Returns needed height while creating texture.
-		int getTextureSrcHeight() const { return mReqTexSize.height; }
-
-		/// Returns needed sizes while creating texture.
-		IntSize getTextureSrcSize() const { return mReqTexSize; }
-
-		/// Returns needed sizes while creating texture.
-		PixelFormat getTextureFormat() const { return mTexture->getFormat(); }
-
-		/// Returns name of the current texture.
-		const std::string& getTextureName() const { return mTexture->getName(); }
-
-		//! @copydoc Widget::setSize(const IntSize& _value)
-		virtual void setSize(const IntSize& _value);
-		//! @copydoc Widget::setCoord(const IntCoord& _value)
-		virtual void setCoord(const IntCoord& _value);
-
-		/** @copydoc Widget::setSize(int _width, int _height) */
-		void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
-		/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
-		void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
-
-		/// Returns resize mode
-		TextureResizeMode getResizeMode() const { return mTexResizeMode; }
-
-		/// Sets resize mode of texture \sa TextureResizeMode
-		void setResizeMode( TextureResizeMode _set ) { mTexResizeMode = _set; }
-
-		/// Checks if the texture has the source (required by user) size, otherwise real texture size are bigger.
-		bool isTextureSrcSize() const;
-
-		/// Returns true if the texture was created (and exists), otherwise false
-		bool isTextureCreated() const { return mTexture != nullptr; }
-
-		/// Returns true if we own the texture, otherwise false. \sa mManaged
-		bool isTextureManaged() const { return mTexManaged; }
-
-		/// Reurns interface texture.
-		ITexture* getTexture() { return mTexture; }
-
-		/// Sets the texture managed @remarks Be careful with assigning managed status to texture, which wasn't created in Canvas! \sa mManaged
-		void setTextureManaged( bool _value ) { mTexManaged = _value; }
-
-		/// Returns default GUI texture usage
-		static TextureUsage getDefaultTextureUsage() { return TextureUsage::Stream | TextureUsage::Write; }
-
-		/// Returns default GUI texture format
-		static PixelFormat getDefaultTextureFormat() { return PixelFormat::R8G8B8A8; }
-
-	/*event:*/
-		/** Event : Notify user texture instance will be changed \sa requestUpdateCanvas\n
-			signature : void method(MyGUI::Canvas* _canvas)\n
-			@param _canvas, which will be updated
-		 */
-		EventInfo_Canvas eventPreTextureChanges;
-
-		/** Event : Texture instance was changed (May be caused by resizing texture or lossing device). User have to update all references to new instance of texture.\n
-			signature : void method(MyGUI::Canvas* _canvas, MyGUI::Canvas::Event _event)\n
-			@param _canvas, which needs to update
-			@param _event
-		 */
-		EventInfo_CanvasEvent requestUpdateCanvas;
-
-	/*internal:*/
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-	protected:
-		virtual ~Canvas();
-
-		/// Destroys texture
-		void _destroyTexture( bool _sendEvent );
-
-		/// Update entered parameters according to current texture resize mode(size) and restore (if can) parameters of usage and format from texture
-		void validate( int& _width, int& _height, TextureUsage& _usage, PixelFormat& _format ) const;
-
-		/// Creates the texture itself
-		void createExactTexture( int _width, int _height, TextureUsage _usage, PixelFormat _format );
-
-		/// Checks if we need to create a texture with such sizes.
-		bool checkCreate( int _width, int _height ) const;
-
-		/// Calls when resize widget
-		void resize( const IntSize& _size );
-
-		/// Correct texture uv-coordinates
-		void correctUV();
-
-		//! @copydoc Widget::baseChangeWidgetSkin(ResourceSkin* _info)
-		void baseChangeWidgetSkin( ResourceSkin* _info );
-
-		//! @copydoc Widget::initialiseWidgetSkin(ResourceSkin* _info)
-		void initialiseWidgetSkin( ResourceSkin* _info );
-
-		//! @copydoc Widget::shutdownWidgetSkin()
-		void shutdownWidgetSkin();
-
-		/// For updating once per frame.
-		void frameAdvise( bool _advise );
-
-		/// For updating once per frame.
-		void frameEntered( float _time );
-
-		virtual void textureInvalidate(ITexture* _texture);
-
-	protected:
-		/// Current texture
-		ITexture* mTexture;
-
-		/// Requested bu user sizes
-		IntSize mReqTexSize;
-
-		/// Generated texture name
-		std::string mGenTexName;
-
-		/// Texture resize mode \sa TextureResizeMode
-		TextureResizeMode mTexResizeMode;
-
-		/// Saved pointer from last calling lock. \sa lock
-		uint8* mTexData;
-
-		/// true if we own the texture (can delete it or replace by another instance), otherwise false
-		bool mTexManaged;
-
-		/// For updating once per frame. True state means updating before next frame starts.
-		bool mFrameAdvise;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_CANVAS_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CastWidget.h

@@ -1,47 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		12/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CAST_WIDGET_H__
-#define __MYGUI_CAST_WIDGET_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Widget.h"
-
-namespace MyGUI
-{
-
-#ifndef MYGUI_DONT_USE_OBSOLETE
-
-	// шаблонный класс для проверки типа виджета
-	template <typename T>
-	MYGUI_OBSOLETE("use : template<typename Type> Type* Widget::castType(bool _throw)")
-	T* castWidget(Widget * _widget)
-	{
-		MYGUI_DEBUG_ASSERT(nullptr != _widget, "Error static cast, widget == nullptr");
-		return _widget->castType<T>();
-	}
-
-#endif // MYGUI_DONT_USE_OBSOLETE
-
-} // namespace MyGUI
-
-#endif // __MYGUI_CAST_WIDGET_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ChildSkinInfo.h

@@ -1,73 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		12/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CHILD_SKIN_INFO_H__
-#define __MYGUI_CHILD_SKIN_INFO_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_WidgetStyle.h"
-
-namespace MyGUI
-{
-
-	struct MYGUI_EXPORT ChildSkinInfo
-	{
-		ChildSkinInfo() : style(WidgetStyle::Child), align(Align::Default) { }
-
-		ChildSkinInfo(const std::string& _type, const WidgetStyle& _style, const std::string& _skin, const IntCoord& _coord, const Align& _align, const std::string& _layer, const std::string& _name) :
-			type(_type),
-			skin(_skin),
-			name(_name),
-			layer(_layer),
-			style(_style),
-			coord(_coord),
-			align(_align)
-		{
-			// set Child style by default
-			if (style == WidgetStyle::MAX) style = WidgetStyle::Child;
-		}
-
-		void addParam(const std::string& _key, const std::string& _value)
-		{
-			params[_key] = _value;
-		}
-
-		std::string findValue(const std::string& _key) const
-		{
-			MapString::const_iterator iter = params.find(_key);
-			if (iter != params.end()) return iter->second;
-			return "";
-		}
-
-		std::string type, skin, name, layer;
-		WidgetStyle style;
-		IntCoord coord;
-		Align align;
-		MapString params;
-	};
-
-	typedef std::vector<ChildSkinInfo> VectorChildSkinInfo;
-
-} // namespace MyGUI
-
-
-#endif // __MYGUI_CHILD_SKIN_INFO_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ClipboardManager.h

@@ -1,70 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CLIPBOARD_MANAGER_H__
-#define __MYGUI_CLIPBOARD_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_UString.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT ClipboardManager
-	{
-		MYGUI_INSTANCE_HEADER( ClipboardManager )
-
-	public:
-		void initialise();
-		void shutdown();
-
-		/** Set current data in clipboard
-			@param _type of data (for example "Text")
-			@param _data
-		*/
-		void setClipboardData(const std::string& _type, const std::string& _data);
-		/** Clear specific type data
-			@param _type of data to delete (for example "Text")
-		*/
-		void clearClipboardData(const std::string& _type);
-		/** Get specific type data
-			@param _type of data to get (for example "Text")
-		*/
-		std::string getClipboardData(const std::string& _type);
-
-	private:
-		MapString mClipboardData;
-
-#if MYGUI_PLATFORM == MYGUI_PLATFORM_WIN32
-	// дискриптор нашего главного окна
-	size_t mHwnd;
-	// строка, которую мы положили в буфер обмена винды
-	UString mPutTextInClipboard;
-#endif
-
-	};
-
-}
-
-#endif // __MYGUI_CLIPBOARD_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Colour.h

@@ -1,163 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		12/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_COLOUR_H__
-#define __MYGUI_COLOUR_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-
-namespace MyGUI
-{
-
-	struct MYGUI_EXPORT Colour
-	{
-		float red, green, blue, alpha;
-
-		static const Colour Zero;
-		static const Colour Black;
-		static const Colour White;
-		static const Colour Red;
-		static const Colour Green;
-		static const Colour Blue;
-
-		Colour() : red( 1 ), green( 1 ), blue( 1 ), alpha( 1 ) { }
-		Colour( float _red, float _green, float _blue, float _alpha = 1 ) : red( _red ), green( _green ), blue( _blue ), alpha( _alpha ) { }
-		explicit Colour(const std::string& _value) { *this = parse(_value); }
-
-
-		Colour& operator=( Colour const& _value )
-		{
-			red = _value.red;
-			green = _value.green;
-			blue = _value.blue;
-			alpha = _value.alpha;
-			return *this;
-		}
-
-		bool operator==( Colour const& _value ) const
-		{
-			return ((red == _value.red) && (green == _value.green) && (blue == _value.blue) && (alpha == _value.alpha));
-		}
-
-		bool operator!=( Colour const& _value ) const
-		{
-			return ! (*this == _value);
-		}
-
-		void set( float _red, float _green, float _blue, float _alpha = 1 )
-		{
-			red = _red;
-			green = _green;
-			blue = _blue;
-			alpha = _alpha;
-		}
-
-		void clear()
-		{
-			red = green = blue = alpha = 0;
-		}
-
-		std::string print() const
-		{
-			std::ostringstream stream;
-			stream << *this;
-			return stream.str();
-		}
-
-		static Colour parse(const std::string& _value)
-		{
-			if (!_value.empty())
-			{
-				if (_value[0] == '#')
-				{
-					std::istringstream stream(_value.substr(1));
-					int result = 0;
-					stream >> std::hex >> result;
-					if (!stream.fail())
-					{
-						return Colour( (unsigned char)( result >> 16 ) / 256.0f, (unsigned char)( result >> 8 ) / 256.0f, (unsigned char)( result ) / 256.0f );
-					}
-				}
-				else
-				{
-					float red, green, blue, alpha = 1;
-					std::istringstream stream(_value);
-					stream >> red >> green >> blue;
-					if (!stream.fail())
-					{
-						if (!stream.eof())
-							stream >> alpha;
-						return Colour(red, green, blue, alpha);
-					}
-				}
-			}
-			return Colour::Zero;
-		}
-
-		friend std::ostream& operator << ( std::ostream& _stream, const Colour&  _value )
-		{
-			_stream << _value.red << " " << _value.green << " " << _value.blue << " " << _value.alpha;
-			return _stream;
-		}
-
-		friend std::istream& operator >> ( std::istream& _stream, Colour&  _value )
-		{
-			_value.clear();
-
-			std::string value;
-			_stream >> value;
-
-			if (value.empty())
-				return _stream;
-
-			if (value[0] == '#')
-			{
-				_value = Colour::parse(value);
-			}
-			else
-			{
-				std::istringstream stream(value);
-				stream >> _value.red;
-				if (stream.fail())
-					_value.clear();
-				else
-				{
-					_stream >> _value.green >> _value.blue;
-					if (!_stream.eof())
-						_stream >> _value.alpha;
-					else
-						_value.alpha = 1;
-
-					if (_stream.fail())
-						_value.clear();
-				}
-			}
-
-			return _stream;
-		}
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_COLOUR_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ComboBox.h

@@ -1,237 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		12/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_COMBO_BOX_H__
-#define __MYGUI_COMBO_BOX_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Edit.h"
-#include "MyGUI_List.h"
-#include "MyGUI_Any.h"
-#include "MyGUI_EventPair.h"
-#include "MyGUI_ControllerFadeAlpha.h"
-
-namespace MyGUI
-{
-
-	typedef delegates::CDelegate2<ComboBox*, size_t> EventHandle_ComboBoxPtrSizeT;
-
-	class MYGUI_EXPORT ComboBox :
-		public Edit
-	{
-		MYGUI_RTTI_DERIVED( ComboBox )
-
-	public:
-		ComboBox();
-
-		//------------------------------------------------------------------------------//
-		// манипуляции айтемами
-
-		//! Get number of items
-		size_t getItemCount() const { return mList->getItemCount(); }
-
-		//! Insert an item into a array at a specified position
-		void insertItemAt(size_t _index, const UString& _name, Any _data = Any::Null);
-
-		//! Add an item to the end of a array
-		void addItem(const UString& _name, Any _data = Any::Null) { return insertItemAt(ITEM_NONE, _name, _data); }
-
-		//! Remove item at a specified position
-		void removeItemAt(size_t _index);
-
-		//! Remove all items
-		void removeAllItems();
-
-
-		//! Search item, returns the position of the first occurrence in array or ITEM_NONE if item not found
-		size_t findItemIndexWith(const UString& _name);
-
-
-		//------------------------------------------------------------------------------//
-		// манипуляции выделениями
-
-		//! Get index of selected item (ITEM_NONE if none selected)
-		size_t getIndexSelected() { return mItemIndex; }
-
-		//! Select specified _index
-		void setIndexSelected(size_t _index);
-
-		//! Clear item selection
-		void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
-
-
-		//------------------------------------------------------------------------------//
-		// манипуляции данными
-
-		//! Replace an item data at a specified position
-		void setItemDataAt(size_t _index, Any _data);
-
-		//! Clear an item data at a specified position
-		void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
-
-		//! Get item data from specified position
-		template <typename ValueType>
-		ValueType * getItemDataAt(size_t _index, bool _throw = true)
-		{
-			return mList->getItemDataAt<ValueType>(_index, _throw);
-		}
-
-
-		//------------------------------------------------------------------------------//
-		// манипуляции отображением
-
-		//! Replace an item name at a specified position
-		void setItemNameAt(size_t _index, const UString& _name);
-
-		//! Get item name from specified position
-		const UString& getItemNameAt(size_t _index) { return mList->getItemNameAt(_index); }
-
-
-		//------------------------------------------------------------------------------//
-		// манипуляции выдимостью
-
-		//! Move all elements so specified becomes visible
-		void beginToItemAt(size_t _index) { mList->beginToItemAt(_index); }
-
-		//! Move all elements so first becomes visible
-		void beginToItemFirst() { if (getItemCount()) beginToItemAt(0); }
-
-		//! Move all elements so last becomes visible
-		void beginToItemLast() { if (getItemCount()) beginToItemAt(getItemCount() - 1); }
-
-		//! Move all elements so selected becomes visible
-		void beginToItemSelected() { if (getIndexSelected() != ITEM_NONE) beginToItemAt(getIndexSelected()); }
-
-
-		//------------------------------------------------------------------------------------//
-		// методы для управления отображением
-
-		//! Set drop list mode (text can not be edited)
-		void setComboModeDrop(bool _value);
-		//! Get drop list mode flag
-		bool getComboModeDrop() { return mModeDrop; }
-
-		//! Set smooth show of list
-		void setSmoothShow(bool _value) { mShowSmooth = _value; }
-		//! Get smooth show of list flag
-		bool getSmoothShow() { return mShowSmooth; }
-
-		//! Get max list height
-		void setMaxListHeight(int _value) { mMaxHeight = _value; }
-		//! Set max list height
-		int getMaxListHeight() { return mMaxHeight; }
-
-		/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	/*event:*/
-		/** Event : Enter pressed in combo mode or item selected in drop.\n
-			signature : void method(MyGUI::ComboBox* _sender, size_t _index)
-			@param _sender widget that called this event
-			@param _index item
-		*/
-		EventPair<EventHandle_WidgetVoid, EventHandle_ComboBoxPtrSizeT> eventComboAccept;
-
-		/** Event : Position changed.\n
-			signature : void method(MyGUI::ComboBox* _sender, size_t _index)
-			@param _sender widget that called this event
-			@param _index of new position
-		*/
-		EventPair<EventHandle_WidgetSizeT, EventHandle_ComboBoxPtrSizeT> eventComboChangePosition;
-
-
-	/*internal:*/
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-	/*obsolete:*/
-#ifndef MYGUI_DONT_USE_OBSOLETE
-
-		MYGUI_OBSOLETE("use : size_t ComboBox::getIndexSelected()")
-		size_t getItemIndexSelected() { return getIndexSelected(); }
-		MYGUI_OBSOLETE("use : void ComboBox::setIndexSelected(size_t _index)")
-		void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
-		MYGUI_OBSOLETE("use : void ComboBox::clearIndexSelected()")
-		void clearItemSelected() { clearIndexSelected(); }
-
-		MYGUI_OBSOLETE("use : void ComboBox::insertItemAt(size_t _index, const UString& _name)")
-		void insertItem(size_t _index, const UString& _name) { insertItemAt(_index, _name); }
-		MYGUI_OBSOLETE("use : void ComboBox::setItemNameAt(size_t _index, const UString& _name)")
-		void setItem(size_t _index, const UString& _item) { setItemNameAt(_index, _item); }
-		MYGUI_OBSOLETE("use : const UString& ComboBox::getItemNameAt(size_t _index)")
-		const UString& getItem(size_t _index) { return getItemNameAt(_index); }
-		MYGUI_OBSOLETE("use : void ComboBox::removeItemAt(size_t _index)")
-		void deleteItem(size_t _index) { removeItemAt(_index); }
-		MYGUI_OBSOLETE("use : void ComboBox::removeAllItems()")
-		void deleteAllItems() { removeAllItems(); }
-		MYGUI_OBSOLETE("use : size_t ComboBox::getIndexSelected()")
-		size_t getItemSelect() { return getIndexSelected(); }
-		MYGUI_OBSOLETE("use : void void ComboBox::clearIndexSelected()")
-		void resetItemSelect() { clearIndexSelected(); }
-		MYGUI_OBSOLETE("use : void ComboBox::setIndexSelected(size_t _index)")
-		void setItemSelect(size_t _index) { setIndexSelected(_index); }
-
-#endif // MYGUI_DONT_USE_OBSOLETE
-
-	protected:
-		virtual ~ComboBox();
-
-		virtual void onKeyButtonPressed(KeyCode _key, Char _char);
-
-		virtual void baseChangeWidgetSkin(ResourceSkin* _info);
-
-	private:
-		void notifyButtonPressed(Widget* _sender, int _left, int _top, MouseButton _id);
-		void notifyListLostFocus(Widget* _sender, MyGUI::Widget* _new);
-		void notifyListSelectAccept(List* _widget, size_t _position);
-		void notifyListMouseItemActivate(List* _widget, size_t _position);
-		void notifyListChangePosition(List* _widget, size_t _position);
-		void notifyMouseWheel(Widget* _sender, int _rel);
-		void notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id);
-		void notifyEditTextChange(Edit* _sender);
-
-		void showList();
-		void hideList();
-
-		void initialiseWidgetSkin(ResourceSkin* _info);
-		void shutdownWidgetSkin();
-
-		void actionWidgetHide(Widget* _widget);
-
-		ControllerFadeAlpha* createControllerFadeAlpha(float _alpha, float _coef, bool _enable);
-
-	private:
-		Button* mButton;
-		List* mList;
-
-		bool mListShow;
-		int mMaxHeight;
-		size_t mItemIndex;
-		bool mModeDrop;
-		bool mDropMouse;
-		bool mShowSmooth;
-		bool mManualList;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_COMBO_BOX_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Common.h

@@ -1,57 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@author		baho_is
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_COMMON_H__
-#define __MYGUI_COMMON_H__
-
-#include "MyGUI_Prerequest.h"
-
-#include <string>
-#include <list>
-#include <set>
-#include <map>
-#include <vector>
-#include <deque>
-#include <exception>
-#include <math.h>
-
-#ifdef MYGUI_CUSTOM_ALLOCATOR
-#    include "MyGUI_CustomAllocator.h"
-#else // MYGUI_CUSTOM_ALLOCATOR
-#    include "MyGUI_Allocator.h"
-#endif // MYGUI_CUSTOM_ALLOCATOR
-
-#include "MyGUI_Macros.h"
-#include "MyGUI_Diagnostic.h"
-#include "MyGUI_LogManager.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_RenderOut.h"
-#include "MyGUI_Utility.h"
-#include "MyGUI_InputDefine.h"
-#include "MyGUI_Version.h"
-#include "MyGUI_WidgetStyle.h"
-#include "MyGUI_UString.h"
-#include "MyGUI_Delegate.h"
-
-#endif // __MYGUI_COMMON_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CommonStateInfo.h

@@ -1,145 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		06/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_COMMON_STATE_INFO_H__
-#define __MYGUI_COMMON_STATE_INFO_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_IStateInfo.h"
-#include "MyGUI_CoordConverter.h"
-#include "MyGUI_LanguageManager.h"
-#include "MyGUI_TextureUtility.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT SubSkinStateInfo :
-		public IStateInfo
-	{
-		MYGUI_RTTI_DERIVED( SubSkinStateInfo )
-
-	public:
-		virtual ~SubSkinStateInfo() { }
-
-		const FloatRect& getRect() { return mRect; }
-
-	private:
-		virtual void deserialization(xml::ElementPtr _node, Version _version)
-		{
-			std::string texture = _node->getParent()->getParent()->findAttribute("texture");
-
-			// ïîääåðæêà çàìåíû òåãîâ â ñêèíàõ
-			if (_version >= Version(1, 1))
-			{
-				texture = LanguageManager::getInstance().replaceTags(texture);
-			}
-
-			const IntSize& size = texture_utility::getTextureSize(texture);
-			const IntCoord& coord = IntCoord::parse(_node->findAttribute("offset"));
-			mRect = CoordConverter::convertTextureCoord(coord, size);
-		}
-
-	private:
-		FloatRect mRect;
-	};
-
-	class MYGUI_EXPORT TileRectStateInfo :
-		public IStateInfo
-	{
-		MYGUI_RTTI_DERIVED( TileRectStateInfo )
-
-	public:
-		TileRectStateInfo() : mTileH(true), mTileV(true) { }
-		virtual ~TileRectStateInfo() { }
-
-		const FloatRect& getRect() { return mRect; }
-		const IntSize& getTileSize() { return mTileSize; }
-		bool getTileH() { return mTileH; }
-		bool getTileV() { return mTileV; }
-
-	private:
-		virtual void deserialization(xml::ElementPtr _node, Version _version)
-		{
-			std::string texture = _node->getParent()->getParent()->findAttribute("texture");
-
-			// ïîääåðæêà çàìåíû òåãîâ â ñêèíàõ
-			if (_version >= Version(1, 1))
-			{
-				texture = LanguageManager::getInstance().replaceTags(texture);
-			}
-
-			const IntSize& size = texture_utility::getTextureSize(texture);
-			const IntCoord& coord = IntCoord::parse(_node->findAttribute("offset"));
-			mRect = CoordConverter::convertTextureCoord(coord, size);
-
-			xml::ElementEnumerator prop = _node->getElementEnumerator();
-			while (prop.next("Property"))
-			{
-				const std::string& key = prop->findAttribute("key");
-				const std::string& value = prop->findAttribute("value");
-				if (key == "TileH") mTileH = utility::parseBool(value);
-				else if (key == "TileV") mTileV = utility::parseBool(value);
-				else if (key == "TileSize") mTileSize = IntSize::parse(value);
-			}
-		}
-
-	private:
-		FloatRect mRect;
-		IntSize mTileSize;
-		bool mTileH;
-		bool mTileV;
-	};
-
-	class MYGUI_EXPORT EditTextStateInfo :
-		public IStateInfo
-	{
-		MYGUI_RTTI_DERIVED( EditTextStateInfo )
-
-	public:
-		EditTextStateInfo() : mColour(Colour::White), mShift(false) { }
-		virtual ~EditTextStateInfo() { }
-
-		const Colour& getColour() { return mColour; }
-		bool getShift() { return mShift; }
-
-	private:
-		virtual void deserialization(xml::ElementPtr _node, Version _version)
-		{
-			mShift = utility::parseBool(_node->findAttribute("shift"));
-
-			std::string colour = _node->findAttribute("colour");
-			if (_version >= Version(1, 1))
-			{
-				colour = LanguageManager::getInstance().replaceTags(colour);
-			}
-
-			mColour = Colour::parse(colour);
-		}
-
-	private:
-		Colour mColour;
-		bool mShift;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_COMMON_STATE_INFO_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerEdgeHide.h

@@ -1,84 +0,0 @@
-/*!
-	@file
-	@author		Evmenov Georgiy
-	@date		04/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CONTROLLER_EDGE_HIDE_H__
-#define __MYGUI_CONTROLLER_EDGE_HIDE_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_WidgetDefines.h"
-#include "MyGUI_ControllerItem.h"
-#include "MyGUI_Types.h"
-
-namespace MyGUI
-{
-
-	/** This controller used for hiding widgets near screen edges.
-		Widget will start hiding(move out of screen) if it's near
-		border and it and it's childrens don't have any focus. Hiding
-		till only small part of widget be visible. Widget will move
-		inside screen if it have any focus.
-	*/
-	class MYGUI_EXPORT ControllerEdgeHide :
-		public ControllerItem
-	{
-		MYGUI_RTTI_DERIVED( ControllerEdgeHide )
-
-	public:
-		ControllerEdgeHide();
-		virtual ~ControllerEdgeHide() { }
-
-		/**
-			@param _value in which widget will be hidden or shown
-		*/
-		void setTime(float _value) { mTime = _value; }
-
-		/**
-			@param _remainPixels how many pixels you will see afterr full hide
-		*/
-		void setRemainPixels(int _value) { mRemainPixels = _value; }
-
-		/**
-			@param _shadowSize adds to _remainPixels when hiding left or top (for example used for windows with shadows)
-		*/
-		void setShadowSize(int _value) { mShadowSize = _value; }
-
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	private:
-		bool addTime(Widget* _widget, float _time);
-		void prepareItem(Widget* _widget);
-
-		void recalculateTime(Widget* _widget);
-
-		delegates::CDelegate1<Widget*> eventPostAction;
-
-		float mTime;
-		int mRemainPixels;
-		int mShadowSize;
-		float mElapsedTime;
-		// for checking if widget was moved
-		MyGUI::IntCoord mLastCoord;
-	};
-
-}
-
-#endif // __MYGUI_CONTROLLER_EDGE_HIDE_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerFadeAlpha.h

@@ -1,78 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CONTROLLER_FADE_ALPHA_H__
-#define __MYGUI_CONTROLLER_FADE_ALPHA_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_WidgetDefines.h"
-#include "MyGUI_ControllerItem.h"
-
-namespace MyGUI
-{
-
-	/** This controller used for smooth changing alpha of widget in time */
-	class MYGUI_EXPORT ControllerFadeAlpha :
-		public ControllerItem
-	{
-		MYGUI_RTTI_DERIVED( ControllerFadeAlpha )
-
-	public:
-		ControllerFadeAlpha();
-		virtual ~ControllerFadeAlpha() { }
-
-		/**
-			@param _alpha that will be as result of changing
-		*/
-		void setAlpha(float _value) { mAlpha = _value; }
-
-		/**
-			@param _coef of alpha changing speed (1. mean that alpha will change from 0 to 1 at 1 second)
-		*/
-		void setCoef(float _value) { mCoef = _value; }
-
-		/**
-			@param _enabled if true then widget will be inactive after start of alpha changing
-		*/
-		void setEnabled(bool _value) { mEnabled = _value; }
-
-
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	private:
-		bool addTime(Widget* _widget, float _time);
-		void prepareItem(Widget* _widget);
-
-		bool getEnabled() { return mEnabled; }
-		float getAlpha() { return mAlpha; }
-		float getCoef() { return mCoef; }
-
-	private:
-		float mAlpha;
-		float mCoef;
-		bool mEnabled;
-
-	};
-
-}
-
-#endif // __MYGUI_CONTROLLER_FADE_ALPHA_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerItem.h

@@ -1,73 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CONTROLLER_ITEM_H__
-#define __MYGUI_CONTROLLER_ITEM_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_WidgetDefines.h"
-#include "MyGUI_IObject.h"
-#include "MyGUI_Delegate.h"
-
-namespace MyGUI
-{
-
-	/** Base interface for controllers */
-	class MYGUI_EXPORT ControllerItem :
-		public IObject
-	{
-		MYGUI_RTTI_DERIVED( ControllerItem )
-
-	public:
-		virtual ~ControllerItem() { }
-
-		virtual void prepareItem(Widget* _widget) = 0;
-		virtual bool addTime(Widget* _widget, float _time) = 0;
-
-		virtual void setProperty(const std::string& _key, const std::string& _value) { }
-
-		/** Event : Before controller started working.\n
-			signature : void method(MyGUI::Widget* _sender)\n
-			@param _sender widget under control
-		*/
-		delegates::CDelegate1<Widget*>
-			eventPreAction;
-
-		/** Event : Controller updated (called every frame).\n
-			signature : void method(MyGUI::Widget* _sender)\n
-			@param _sender widget under control
-		*/
-		delegates::CDelegate1<Widget*>
-			eventUpdateAction;
-
-		/** Event : After controller finished working.\n
-			signature : void method(MyGUI::Widget* _sender)\n
-			@param _sender widget under control
-		*/
-		delegates::CDelegate1<Widget*>
-			eventPostAction;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_CONTROLLER_ITEM_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerManager.h

@@ -1,74 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CONTROLLER_MANAGER_H__
-#define __MYGUI_CONTROLLER_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_ControllerItem.h"
-#include "MyGUI_IUnlinkWidget.h"
-#include "MyGUI_WidgetDefines.h"
-#include "MyGUI_ActionController.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT ControllerManager : public IUnlinkWidget
-	{
-		MYGUI_INSTANCE_HEADER( ControllerManager )
-
-	public:
-		void initialise();
-		void shutdown();
-
-		// ñîçäàåò êîíòðîëëåð
-		ControllerItem* createItem(const std::string& _type);
-
-		/** Add controlled widget
-			@param _widget to be controlled
-			@param _item controller with some actions (for example ControllerFadeAlpha or your own)
-			@note _item will be deleted automatically at end of controller lifetime
-				(if not removed by removeItem(Widget* _widget) before)
-		*/
-		void addItem(Widget* _widget, ControllerItem * _item);
-
-		/** Stop the control over a widget
-			@param _widget to be removed
-		*/
-		void removeItem(Widget* _widget);
-
-	private:
-		void _unlinkWidget(Widget* _widget);
-		void frameEntered(float _time);
-		void clear();
-
-	private:
-		typedef std::pair<Widget*, ControllerItem *> PairControllerItem;
-		typedef std::list<PairControllerItem> ListControllerItem;
-		ListControllerItem mListItem;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_CONTROLLER_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ControllerPosition.h

@@ -1,95 +0,0 @@
-/*!
-	@file
-	@author		Evmenov Georgiy
-	@date		03/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CONTROLLER_POSITION_H__
-#define __MYGUI_CONTROLLER_POSITION_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Delegate.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_WidgetDefines.h"
-#include "MyGUI_ControllerItem.h"
-
-namespace MyGUI
-{
-
-	/** This controller used for smooth changing position of widget in time */
-	class MYGUI_EXPORT ControllerPosition :
-		public ControllerItem
-	{
-		MYGUI_RTTI_DERIVED( ControllerPosition )
-
-	public:
-		typedef delegates::CDelegate4<const IntCoord&, const IntCoord&, IntCoord&, float> FrameAction;
-
-		ControllerPosition();
-		virtual ~ControllerPosition() { }
-
-		void setCoord(const IntCoord& _value);
-
-		void setSize(const IntSize& _value);
-
-		void setPosition(const IntPoint& _value);
-
-		void setFunction(const std::string& _value);
-
-		/**
-			@param _value seconds in which widget planned to reach destination coordinate
-		*/
-		void setTime(float _value) { mTime = _value; }
-
-		/**
-			@param _action applied to widget every frame (see ControllerPosition::eventFrameAction)
-		*/
-		void setAction(FrameAction::IDelegate* _value) { eventFrameAction = _value; }
-
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	private:
-		bool addTime(Widget* _widget, float _time);
-		void prepareItem(Widget* _widget);
-
-		float getElapsedTime() { return mElapsedTime; }
-
-		IntCoord mStartCoord;
-		IntCoord mDestCoord;
-		float mTime;
-		float mElapsedTime;
-
-		// controller changing position
-		bool mCalcPosition;
-		// controller changing size
-		bool mCalcSize;
-
-		/** Event : Every frame action while controller exist.\n
-			signature : void method(const IntRect& _startRect, const IntRect& _destRect, IntRect& _result, float _current_time)\n
-			@param _startRect start coordinate of widget
-			@param _destRect destination coordinate
-			@param _result resultRect
-			@param _current_time elapsed time (_current_time is real elapsed time divided by _time(see constructor) so _current_time == 1 mean that _time seconds elapsed)
-		*/
-		FrameAction eventFrameAction;
-	};
-
-}
-
-#endif // __MYGUI_CONTROLLER_POSITION_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CoordConverter.h

@@ -1,92 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		06/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_COORD_CONVERTER_H__
-#define __MYGUI_COORD_CONVERTER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT CoordConverter
-	{
-	public:
-		/** Convert pixel coordinates to texture UV coordinates */
-		static FloatRect convertTextureCoord(const IntCoord& _coord, const IntSize& _textureSize)
-		{
-			if (!_textureSize.width || !_textureSize.height) return FloatRect();
-			return FloatRect(
-			(float)_coord.left / (float)_textureSize.width,
-			(float)_coord.top / (float)_textureSize.height,
-			(float)_coord.right() / (float)_textureSize.width,
-			(float)_coord.bottom() / (float)_textureSize.height);
-		}
-
-		/* Convert from relative to pixel coordinates.
-			@param _coord relative coordinates.
-		*/
-		static IntCoord convertFromRelative(const FloatCoord& _coord, const IntSize& _view)
-		{
-			return IntCoord(int(_coord.left * _view.width), int(_coord.top * _view.height), int(_coord.width * _view.width), int(_coord.height * _view.height));
-		}
-
-		/* Convert from relative to pixel coordinates.
-			@param _coord relative coordinates.
-		*/
-		static IntSize convertFromRelative(const FloatSize& _size, const IntSize& _view)
-		{
-			return IntSize(int(_size.width * _view.width), int(_size.height * _view.height));
-		}
-
-		/* Convert from relative to pixel coordinates.
-			@param _coord relative coordinates.
-		*/
-		static IntPoint convertFromRelative(const FloatPoint& _point, const IntSize& _view)
-		{
-			return IntPoint(int(_point.left * _view.width), int(_point.top * _view.height));
-		}
-
-		/* Convert from pixel to relative coordinates.
-			@param _coord pixel coordinates.
-		*/
-		static FloatCoord convertToRelative(const IntCoord& _coord, const IntSize& _view)
-		{
-			return FloatCoord(_coord.left / (float)_view.width, _coord.top / (float)_view.height, _coord.width / (float)_view.width, _coord.height / (float)_view.height);
-		}
-
-		static FloatSize convertToRelative(const IntSize& _size, const IntSize& _view)
-		{
-			return FloatSize(_size.width / (float)_view.width, _size.height / (float)_view.height);
-		}
-
-		static FloatPoint convertToRelative(const IntPoint& _point, const IntSize& _view)
-		{
-			return FloatPoint(_point.left / (float)_view.width, _point.top / (float)_view.height);
-		}
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_COORD_CONVERTER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_CustomAllocator.h

@@ -1,101 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_CUSTOM_ALLOCATOR_H__
-#define __MYGUI_CUSTOM_ALLOCATOR_H__
-
-#include <memory>
-#include <limits>
-
-// for Ogre version
-#include <OgrePrerequisites.h>
-
-#if OGRE_VERSION < MYGUI_DEFINE_VERSION(1, 6, 0)
-#include <OgreMemoryManager.h>
-#include <OgreNoMemoryMacros.h>
-#endif
-
-namespace MyGUI
-{
-
-	template<typename T>
-	class Allocator
-	{
-	public:
-		//    typedefs
-		typedef T value_type;
-		typedef value_type* pointer;
-		typedef const value_type* const_pointer;
-		typedef value_type& reference;
-		typedef const value_type& const_reference;
-		typedef std::size_t size_type;
-		typedef std::ptrdiff_t difference_type;
-
-	public:
-		//    convert an allocator<T> to allocator<U>
-		template<typename U>
-		struct rebind
-		{
-			typedef Allocator<U> other;
-		};
-
-	public:
-		inline explicit Allocator() { }
-		inline ~Allocator() { }
-		template<typename U>
-		inline explicit Allocator(Allocator<U> const&) { }
-
-		//    address
-		inline pointer address(reference r) { return &r; }
-		inline const_pointer address(const_reference r) { return &r; }
-
-		//    memory allocation
-		inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0)
-		{
-			return reinterpret_cast<pointer>(::operator new (cnt * sizeof (T)));
-		}
-		inline void deallocate(pointer p, size_type)
-		{
-			::operator delete (p);
-		}
-
-		//    size
-		inline size_type max_size() const
-		{
-			return std::numeric_limits<size_type>::max() / sizeof(T);
-		}
-
-		//    construction/destruction
-		inline void construct(pointer p, const T& t) { new (p) T(t); }
-		inline void destroy(pointer p) { p->~T(); }
-
-		inline bool operator==(Allocator const&) { return true; }
-		inline bool operator!=(Allocator const& a) { return !operator==(a); }
-	};
-
-} // namespace MyGUI
-
-#if OGRE_VERSION < MYGUI_DEFINE_VERSION(1, 6, 0)
-#include <OgreMemoryMacros.h>
-#endif
-
-#endif // __MYGUI_CUSTOM_ALLOCATOR_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DDContainer.h

@@ -1,175 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		10/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DDCONTAINER_H__
-#define __MYGUI_DDCONTAINER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Widget.h"
-#include "MyGUI_DDItemInfo.h"
-#include "MyGUI_EventPair.h"
-
-namespace MyGUI
-{
-
-	typedef delegates::CDelegate3<DDContainer*, const DDItemInfo&, bool&> EventHandle_DDContainerPtrCDDItemInfoRefBoolRef;
-	typedef delegates::CDelegate3<DDContainer*, const DDItemInfo&, bool> EventHandle_DDContainerPtrCDDItemInfoRefBool;
-	typedef delegates::CDelegate2<DDContainer*, DDItemState> EventHandle_EventHandle_DDContainerPtrDDItemState;
-	typedef delegates::CDelegate3<DDContainer*, WidgetPtr&, IntCoord&> EventHandle_EventHandle_DDContainerPtrWidgetPtrRefIntCoordRef;
-
-
-	class MYGUI_EXPORT DDContainer :
-		public Widget
-	{
-		MYGUI_RTTI_DERIVED( DDContainer )
-
-	public:
-		DDContainer();
-
-		/** Set drag'n'drop mode flag.
-			Disabled (false) by default.
-		*/
-		void setNeedDragDrop(bool _value) { mNeedDragDrop = _value; }
-		/** Get drag'n'drop mode flag */
-		bool getNeedDragDrop() { return mNeedDragDrop; }
-
-		/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	/*event:*/
-		/** Event : request for start drag
-			signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool& _result)
-			@param _sender widget that called this event
-			@param _info information about DDContainers
-			@param _result write here true if container can be draggedor false if it can't
-		*/
-		EventHandle_DDContainerPtrCDDItemInfoRefBoolRef eventStartDrag;
-
-		/** Event : request for start drag (moving mouse over container, but not dropped yet)
-			signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool& _result)
-			@param _sender widget that called this event
-			@param _info information about DDContainers
-			@param _result write here true if container accept dragged widget or false if it isn't
-		*/
-		EventHandle_DDContainerPtrCDDItemInfoRefBoolRef eventRequestDrop;
-
-		/** Event : end drag (drop)
-			signature : void method(MyGUI::DDContainer* _sender, const MyGUI::DDItemInfo& _info, bool _result)
-			@param _sender widget that called this event
-			@param _info information about DDContainers
-			@param _result if true then drop was successfull
-		*/
-		EventHandle_DDContainerPtrCDDItemInfoRefBool eventDropResult;
-
-		/** Event : drag'n'drop state changed
-			signature : void method(MyGUI::DDContainer* _sender, MyGUI::DDItemState _state)
-			@param _sender widget that called this event
-			@param _state new state
-		*/
-		EventHandle_EventHandle_DDContainerPtrDDItemState eventChangeDDState;
-
-		/** Event : [not used] request widget for dragging
-			signature : void method(MyGUI::DDContainer* _sender, MyGUI::Widget*& _item, MyGUI::IntCoord& _dimension)
-			@param _sender widget that called this event
-			@param _item write widget pointer here
-			@param _dimension write widget coordinate here
-		*/
-		EventHandle_EventHandle_DDContainerPtrWidgetPtrRefIntCoordRef requestDragWidgetInfo;
-
-
-	/*internal:*/
-		// метод для установления стейта айтема
-		virtual void _setContainerItemInfo(size_t _index, bool _set, bool _accept) { }
-
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-		/** Event : внутреннее событие, невалидна информация для контейнера
-			signature : void method(MyGUI::DDContainer* _sender)
-			@param _sender widget that called this event
-		*/
-		EventPair<EventHandle_WidgetVoid, delegates::CDelegate1<DDContainer*> >
-			_eventInvalideContainer;
-
-		/** Event : !!обновить виджеты дропа DD_FIXME наверное internal
-			signature : void method(MyGUI::DDContainer* _sender, MyGUI::Widget* _item, const MyGUI::DDWidgetState& _state)
-			@param _sender widget that called this event
-			@param _items
-			@param _state
-		*/
-		delegates::CDelegate3<DDContainer*, Widget*, const DDWidgetState&>
-			eventUpdateDropState;
-
-	protected:
-		virtual ~DDContainer();
-
-		void baseChangeWidgetSkin(ResourceSkin* _info);
-
-		virtual void onMouseButtonPressed(int _left, int _top, MouseButton _id);
-		virtual void onMouseButtonReleased(int _left, int _top, MouseButton _id);
-		virtual void onMouseDrag(int _left, int _top);
-
-		virtual void notifyInvalideDrop(DDContainer* _sender);
-
-		virtual void _getContainer(Widget*& _container, size_t& _index);
-
-		virtual void removeDropItems();
-		virtual void updateDropItems();
-		virtual void updateDropItemsState(const DDWidgetState& _state);
-
-		void mouseDrag();
-		void mouseButtonReleased(MouseButton _id);
-		void mouseButtonPressed(MouseButton _id);
-
-		void endDrop(bool _reset);
-
-	private:
-		void initialiseWidgetSkin(ResourceSkin* _info);
-		void shutdownWidgetSkin();
-
-
-	protected:
-		bool mDropResult;
-		bool mNeedDrop;
-		bool mStartDrop;
-
-		Widget* mOldDrop;
-		Widget* mCurrentSender;
-
-		DDItemInfo mDropInfo;
-
-		size_t mDropSenderIndex;
-
-		// список виджетов для дропа
-		Widget* mDropItem;
-		IntCoord mDropDimension;
-
-		IntPoint mClickInWidget;
-
-		// нужно и виджету поддержка драг энд дропа
-		bool mNeedDragDrop;
-
-		DDContainer* mReseiverContainer;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_DDCONTAINER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DDItemInfo.h

@@ -1,120 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		01/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ITEM_DROP_INFO_H__
-#define __MYGUI_ITEM_DROP_INFO_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	struct MYGUI_EXPORT DDItemState
-	{
-		enum Enum
-		{
-			None,
-			Start, /**< start drag */
-			End, /**< end drag (drop) */
-			Miss, /**< drag DDContainer over empty space or widgets that don't have drag'n'drop */
-			Accept, /**< drag DDContainer over another DDContainer that accept dropping on it */
-			Refuse /**< drag DDContainer over another DDContainer that refuse dropping on it */
-		};
-
-		DDItemState(Enum _value = None) : value(_value) { }
-
-		friend bool operator == (DDItemState const& a, DDItemState const& b) { return a.value == b.value; }
-		friend bool operator != (DDItemState const& a, DDItemState const& b) { return a.value != b.value; }
-
-	private:
-		Enum value;
-	};
-
-	// структура информации об индексах дропа
-	/** Inormation about drag'n'drop indexes */
-	struct MYGUI_EXPORT DDItemInfo
-	{
-		DDItemInfo() :
-			sender(nullptr),
-			sender_index(ITEM_NONE),
-			receiver(nullptr),
-			receiver_index(ITEM_NONE)
-		{
-		}
-
-		DDItemInfo(DDContainer* _sender, size_t _sender_index, DDContainer* _receiver, size_t _receiver_index) :
-			sender(_sender),
-			sender_index(_sender_index),
-			receiver(_receiver),
-			receiver_index(_receiver_index)
-		{
-		}
-
-		void set(DDContainer* _sender, size_t _sender_index, DDContainer* _receiver, size_t _receiver_index)
-		{
-			sender = _sender;
-			sender_index = _sender_index;
-			receiver = _receiver;
-			receiver_index = _receiver_index;
-		}
-
-		void reset()
-		{
-			sender = nullptr;
-			sender_index = ITEM_NONE;
-			receiver = nullptr;
-			receiver_index = ITEM_NONE;
-		}
-
-		/** DDContainer that send this event (container from which we started drag) */
-		DDContainer* sender;
-		/** Index of sender container */
-		size_t sender_index;
-
-		/** DDContainer that receive dragged widget (container to which we want to drop) */
-		DDContainer* receiver;
-		/** Index of receiver container */
-		size_t receiver_index;
-	};
-
-	struct MYGUI_EXPORT DDWidgetState
-	{
-		DDWidgetState(size_t _index) :
-			index(_index),
-			update(true),
-			accept(false),
-			refuse(false)
-		{ }
-
-		/** Index of element */
-		size_t index;
-		/** State and internal data changed */
-		bool update;
-		/** Is widget accept drop */
-		bool accept;
-		/** Is widget refuse drop */
-		bool refuse;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ITEM_DROP_INFO_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataFileStream.h

@@ -1,45 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DATA_FILE_STREAM_H__
-#define __MYGUI_DATA_FILE_STREAM_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_DataStream.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT DataFileStream : public DataStream
-	{
-	public:
-		DataFileStream();
-		DataFileStream(std::ifstream* _stream);
-		~DataFileStream();
-
-	private:
-		std::ifstream* mFileStream;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_DATA_STREAM_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataManager.h

@@ -1,56 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DATA_MANAGER_H__
-#define __MYGUI_DATA_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_IDataStream.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT DataManager
-	{
-	public:
-		DataManager();
-		virtual ~DataManager() = 0;
-
-		static DataManager& getInstance();
-		static DataManager* getInstancePtr();
-
-		virtual IDataStream* getData(const std::string& _name) = 0;
-
-		virtual bool isDataExist(const std::string& _name) = 0;
-
-		virtual const VectorString& getDataListNames(const std::string& _pattern) = 0;
-
-		virtual const std::string& getDataPath(const std::string& _name) = 0;
-
-	private:
-		static DataManager* msInstance;
-		bool mIsInitialise;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_DATA_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DataStream.h

@@ -1,51 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DATA_STREAM_H__
-#define __MYGUI_DATA_STREAM_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_IDataStream.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT DataStream : public IDataStream
-	{
-	public:
-		DataStream();
-		DataStream(std::istream* _stream);
-		virtual ~DataStream();
-
-		virtual bool eof();
-		virtual size_t size();
-		virtual void readline(std::string& _source, Char _delim);
-		virtual size_t read(void* _buf, size_t _count);
-
-	protected:
-		std::istream* mStream;
-		size_t mSize;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_DATA_STREAM_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Delegate.h

@@ -1,137 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DELEGATE_H__
-#define __MYGUI_DELEGATE_H__
-
-#include "MyGUI_Diagnostic.h"
-#include <typeinfo>
-#include <list>
-
-// source
-// http://rsdn.ru/article/cpp/delegates.xml
-
-// генерация делегатов для различного колличества параметров
-namespace MyGUI
-{
-
-	namespace delegates
-	{
-		// базовый класс для тех классов, что хотят себя отвязывать от мульти делегатов
-		class MYGUI_EXPORT IDelegateUnlink
-		{
-		public:
-			virtual ~IDelegateUnlink() { }
-
-			IDelegateUnlink() { m_baseDelegateUnlink = this; }
-			bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; }
-
-		private:
-			IDelegateUnlink * m_baseDelegateUnlink;
-		};
-
-		inline IDelegateUnlink * GetDelegateUnlink(void * _base) { return 0; }
-		inline IDelegateUnlink * GetDelegateUnlink(IDelegateUnlink * _base) { return _base; }
-	}
-
-	// без параметров
-	#define MYGUI_SUFFIX       0
-	#define MYGUI_TEMPLATE
-	#define MYGUI_TEMPLATE_PARAMS
-	#define MYGUI_TEMPLATE_ARGS
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T>
-	#define MYGUI_T_TEMPLATE_ARGS <T>
-	#define MYGUI_PARAMS
-	#define MYGUI_ARGS
-	#define MYGUI_TYPENAME
-
-	#include "MyGUI_DelegateImplement.h"
-
-	// один параметр
-	#define MYGUI_SUFFIX       1
-	#define MYGUI_TEMPLATE	template
-	#define MYGUI_TEMPLATE_PARAMS  <typename TP1>
-	#define MYGUI_TEMPLATE_ARGS    <TP1>
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T, typename TP1>
-	#define MYGUI_T_TEMPLATE_ARGS    <T, TP1>
-	#define MYGUI_PARAMS       TP1 p1
-	#define MYGUI_ARGS         p1
-	#define MYGUI_TYPENAME     typename
-
-	#include "MyGUI_DelegateImplement.h"
-
-	// два параметра
-	#define MYGUI_SUFFIX       2
-	#define MYGUI_TEMPLATE	template
-	#define MYGUI_TEMPLATE_PARAMS  <typename TP1, typename TP2>
-	#define MYGUI_TEMPLATE_ARGS    <TP1, TP2>
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T, typename TP1, typename TP2>
-	#define MYGUI_T_TEMPLATE_ARGS    <T, TP1, TP2>
-	#define MYGUI_PARAMS       TP1 p1, TP2 p2
-	#define MYGUI_ARGS         p1, p2
-	#define MYGUI_TYPENAME     typename
-
-	#include "MyGUI_DelegateImplement.h"
-
-	// три параметра
-	#define MYGUI_SUFFIX       3
-	#define MYGUI_TEMPLATE	template
-	#define MYGUI_TEMPLATE_PARAMS  <typename TP1, typename TP2, typename TP3>
-	#define MYGUI_TEMPLATE_ARGS    <TP1, TP2, TP3>
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T, typename TP1, typename TP2, typename TP3>
-	#define MYGUI_T_TEMPLATE_ARGS    <T, TP1, TP2, TP3>
-	#define MYGUI_PARAMS       TP1 p1, TP2 p2, TP3 p3
-	#define MYGUI_ARGS         p1, p2, p3
-	#define MYGUI_TYPENAME     typename
-
-	#include "MyGUI_DelegateImplement.h"
-
-	// четыре параметра
-	#define MYGUI_SUFFIX       4
-	#define MYGUI_TEMPLATE	template
-	#define MYGUI_TEMPLATE_PARAMS  <typename TP1, typename TP2, typename TP3, typename TP4>
-	#define MYGUI_TEMPLATE_ARGS    <TP1, TP2, TP3, TP4>
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T, typename TP1, typename TP2, typename TP3, typename TP4>
-	#define MYGUI_T_TEMPLATE_ARGS    <T, TP1, TP2, TP3, TP4>
-	#define MYGUI_PARAMS       TP1 p1, TP2 p2, TP3 p3, TP4 p4
-	#define MYGUI_ARGS         p1, p2, p3, p4
-	#define MYGUI_TYPENAME     typename
-
-	#include "MyGUI_DelegateImplement.h"
-
-	// пять параметров
-	#define MYGUI_SUFFIX       5
-	#define MYGUI_TEMPLATE	template
-	#define MYGUI_TEMPLATE_PARAMS  <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
-	#define MYGUI_TEMPLATE_ARGS    <TP1, TP2, TP3, TP4, TP5>
-	#define MYGUI_T_TEMPLATE_PARAMS  <typename T, typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
-	#define MYGUI_T_TEMPLATE_ARGS    <T, TP1, TP2, TP3, TP4, TP5>
-	#define MYGUI_PARAMS       TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5
-	#define MYGUI_ARGS         p1, p2, p3, p4, p5
-	#define MYGUI_TYPENAME     typename
-
-	#include "MyGUI_DelegateImplement.h"
-
-
-} // namespace MyGUI
-
-#endif // __MYGUI_DELEGATE_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DelegateImplement.h

@@ -1,319 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-namespace delegates
-{
-
-	#define MYGUI_COMBINE(a, b)									MYGUI_COMBINE1(a, b)
-	#define MYGUI_COMBINE1(a, b)								a##b
-
-	#define MYGUI_I_DELEGATE									MYGUI_COMBINE(IDelegate, MYGUI_SUFFIX)
-
-	#define MYGUI_C_STATIC_DELEGATE					MYGUI_COMBINE(CStaticDelegate, MYGUI_SUFFIX)
-	#define MYGUI_C_METHOD_DELEGATE					MYGUI_COMBINE(CMethodDelegate, MYGUI_SUFFIX)
-
-	#define MYGUI_C_DELEGATE									MYGUI_COMBINE(CDelegate, MYGUI_SUFFIX)
-	#define MYGUI_C_MULTI_DELEGATE						MYGUI_COMBINE(CMultiDelegate, MYGUI_SUFFIX)
-
-
-	// базовый класс всех делегатов
-	MYGUI_TEMPLATE   MYGUI_TEMPLATE_PARAMS
-	class MYGUI_I_DELEGATE
-	{
-	public:
-		virtual ~MYGUI_I_DELEGATE() { }
-		virtual bool isType( const std::type_info& _type) = 0;
-		virtual void invoke( MYGUI_PARAMS ) = 0;
-		virtual bool compare(  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  * _delegate) const = 0;
-		virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
-	};
-
-
-	// делегат для статической функции
-	MYGUI_TEMPLATE   MYGUI_TEMPLATE_PARAMS
-	class MYGUI_C_STATIC_DELEGATE : public  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS
-	{
-	public:
-		typedef void (*Func)( MYGUI_PARAMS );
-
-		MYGUI_C_STATIC_DELEGATE (Func _func) : mFunc(_func) { }
-
-		virtual bool isType( const std::type_info& _type) { return typeid( MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS ) == _type; }
-
-		virtual void invoke( MYGUI_PARAMS )
-		{
-			mFunc( MYGUI_ARGS );
-		}
-
-		virtual bool compare(  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  * _delegate) const
-		{
-			if (nullptr == _delegate || !_delegate->isType(typeid(MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS)) ) return false;
-			MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS * cast = static_cast<MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS *>(_delegate);
-			return cast->mFunc == mFunc;
-		}
-		virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
-
-	private:
-		Func mFunc;
-	};
-
-
-	// делегат для метода класса
-	template MYGUI_T_TEMPLATE_PARAMS
-	class MYGUI_C_METHOD_DELEGATE : public  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS
-	{
-	public:
-		typedef void (T::*Method)( MYGUI_PARAMS );
-
-		MYGUI_C_METHOD_DELEGATE(IDelegateUnlink * _unlink, T * _object, Method _method) : mUnlink(_unlink), mObject(_object), mMethod(_method) { }
-
-		virtual bool isType( const std::type_info& _type) { return typeid( MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS ) == _type; }
-
-		virtual void invoke( MYGUI_PARAMS )
-		{
-			(mObject->*mMethod)( MYGUI_ARGS );
-		}
-
-		virtual bool compare(  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  * _delegate) const
-		{
-			if (nullptr == _delegate || !_delegate->isType(typeid(MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS)) ) return false;
-			MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS  * cast = static_cast<  MYGUI_C_METHOD_DELEGATE MYGUI_T_TEMPLATE_ARGS  * >(_delegate);
-			return cast->mObject == mObject && cast->mMethod == mMethod;
-		}
-
-		virtual bool compare(IDelegateUnlink * _unlink) const
-		{
-			return mUnlink == _unlink;
-		}
-
-	private:
-		IDelegateUnlink *mUnlink;
-		T * mObject;
-		Method mMethod;
-	};
-
-} // namespace delegates
-
-// шаблон для создания делегата статической функции
-// параметры : указатель на функцию
-// пример : newDelegate(funk_name);
-// пример : newDelegate(class_name::static_method_name);
-MYGUI_TEMPLATE   MYGUI_TEMPLATE_PARAMS
-inline  delegates::MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  * newDelegate( void (*_func)( MYGUI_PARAMS ) )
-{
-	return new delegates::MYGUI_C_STATIC_DELEGATE MYGUI_TEMPLATE_ARGS  (_func);
-}
-
-
-// шаблон для создания делегата метода класса
-// параметры : указатель на объект класса и указатель на метод класса
-// пример : newDelegate(&object_name, &class_name::method_name);
-template MYGUI_T_TEMPLATE_PARAMS
-inline  delegates::MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  * newDelegate( T * _object, void (T::*_method)( MYGUI_PARAMS ) )
-{
-	return new delegates::MYGUI_C_METHOD_DELEGATE  MYGUI_T_TEMPLATE_ARGS  (delegates::GetDelegateUnlink(_object), _object, _method);
-}
-
-namespace delegates
-{
-	// шаблон класса делегата
-	MYGUI_TEMPLATE   MYGUI_TEMPLATE_PARAMS
-	class MYGUI_C_DELEGATE
-	{
-	public:
-		typedef  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  IDelegate;
-
-		MYGUI_C_DELEGATE () : mDelegate(nullptr) { }
-		MYGUI_C_DELEGATE (const MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS& _event)
-		{
-			// забираем себе владение
-			mDelegate = _event.mDelegate;
-			const_cast< MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS& >(_event).mDelegate = nullptr;
-		}
-		~MYGUI_C_DELEGATE () { clear(); }
-
-		bool empty() const { return mDelegate == nullptr; }
-
-		void clear()
-		{
-			if (mDelegate)
-			{
-				delete mDelegate;
-				mDelegate = nullptr;
-			}
-		}
-
-		MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS & operator=(IDelegate* _delegate)
-		{
-			delete mDelegate;
-			mDelegate = _delegate;
-			return *this;
-		}
-
-		MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS & operator=(const MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS& _event)
-		{
-			// забираем себе владение
-			delete mDelegate;
-			mDelegate = _event.mDelegate;
-			const_cast< MYGUI_C_DELEGATE  MYGUI_TEMPLATE_ARGS& >(_event).mDelegate = nullptr;
-
-			return *this;
-		}
-
-		void operator()( MYGUI_PARAMS )
-		{
-			if (mDelegate == nullptr) return;
-			mDelegate->invoke( MYGUI_ARGS );
-		}
-
-	private:
-		IDelegate * mDelegate;
-	};
-
-
-	// шаблон класса мульти делегата
-	MYGUI_TEMPLATE   MYGUI_TEMPLATE_PARAMS
-	class MYGUI_C_MULTI_DELEGATE
-	{
-	public:
-		typedef  MYGUI_I_DELEGATE MYGUI_TEMPLATE_ARGS  IDelegate;
-		typedef MYGUI_TYPENAME std::list<IDelegate* /*, Allocator<IDelegate*>*/ > ListDelegate;
-		typedef MYGUI_TYPENAME ListDelegate::iterator ListDelegateIterator;
-		typedef MYGUI_TYPENAME ListDelegate::const_iterator ConstListDelegateIterator;
-
-		MYGUI_C_MULTI_DELEGATE () { }
-		~MYGUI_C_MULTI_DELEGATE () { clear(); }
-
-		bool empty() const
-		{
-		  for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
-			{
-				if (*iter) return false;
-			}
-			return true;
-		}
-
-		void clear()
-		{
-			for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
-			{
-				if (*iter)
-				{
-					delete (*iter);
-					(*iter) = nullptr;
-				}
-			}
-		}
-
-		void clear(IDelegateUnlink * _unlink)
-		{
-			for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
-			{
-				if ((*iter) && (*iter)->compare(_unlink))
-				{
-					delete (*iter);
-					(*iter) = nullptr;
-				}
-			}
-		}
-
-		MYGUI_C_MULTI_DELEGATE  MYGUI_TEMPLATE_ARGS & operator+=(IDelegate* _delegate)
-		{
-			for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
-			{
-				if ((*iter) && (*iter)->compare(_delegate))
-				{
-					MYGUI_ASSERT(false, "dublicate delegate");
-				}
-			}
-			mListDelegates.push_back(_delegate);
-			return *this;
-		}
-
-		MYGUI_C_MULTI_DELEGATE  MYGUI_TEMPLATE_ARGS & operator-=(IDelegate* _delegate)
-		{
-			for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
-			{
-				if ((*iter) && (*iter)->compare(_delegate))
-				{
-					// проверяем на идентичность делегатов
-					if ((*iter) != _delegate) delete (*iter);
-					(*iter) = nullptr;
-					break;
-				}
-			}
-			delete _delegate;
-			return *this;
-		}
-
-		void operator()( MYGUI_PARAMS )
-		{
-			ListDelegateIterator iter = mListDelegates.begin();
-			while (iter != mListDelegates.end())
-			{
-				if (nullptr == (*iter))
-				{
-					iter = mListDelegates.erase(iter);
-				}
-				else
-				{
-					(*iter)->invoke( MYGUI_ARGS );
-					++iter;
-				}
-			}
-		}
-
-	private:
-		// constructor and operator =, without implementation, just for private
-		MYGUI_C_MULTI_DELEGATE (const MYGUI_C_MULTI_DELEGATE  MYGUI_TEMPLATE_ARGS & _event);
-		MYGUI_C_MULTI_DELEGATE  MYGUI_TEMPLATE_ARGS & operator=(const MYGUI_C_MULTI_DELEGATE  MYGUI_TEMPLATE_ARGS & _event);
-
-
-	private:
-		ListDelegate mListDelegates;
-
-	};
-
-
-	#undef MYGUI_COMBINE
-	#undef MYGUI_COMBINE1
-
-	#undef MYGUI_I_DELEGATE
-
-	#undef MYGUI_C_STATIC_DELEGATE
-	#undef MYGUI_C_METHOD_DELEGATE
-
-	#undef MYGUI_C_DELEGATE
-	#undef MYGUI_C_MULTI_DELEGATE
-
-	#undef MYGUI_SUFFIX
-	#undef MYGUI_TEMPLATE
-	#undef MYGUI_TEMPLATE_PARAMS
-	#undef MYGUI_TEMPLATE_ARGS
-	#undef MYGUI_T_TEMPLATE_PARAMS
-	#undef MYGUI_T_TEMPLATE_ARGS
-	#undef MYGUI_PARAMS
-	#undef MYGUI_ARGS
-	#undef MYGUI_TYPENAME
-
-} // namespace delegates

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Diagnostic.h

@@ -1,115 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@author		baho_is
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DIAGNOSTIC_H__
-#define __MYGUI_DIAGNOSTIC_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Exception.h"
-#include "MyGUI_LogManager.h"
-#include <sstream>
-
-// for debugging
-#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
-	#include <crtdbg.h>
-#endif
-
-#define MYGUI_LOG_SECTION "Core"
-#define MYGUI_LOG_FILENAME "MyGUI.log"
-#define MYGUI_LOG(level, text) MYGUI_LOGGING(MYGUI_LOG_SECTION, level, text)
-
-#define MYGUI_BASE_EXCEPT(desc, src)	 throw MyGUI::Exception(desc, src, __FILE__, __LINE__);
-
-// MSVC specific: sets the breakpoint
-#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
-	#define MYGUI_DBG_BREAK _CrtDbgBreak();
-#else
-	#define MYGUI_DBG_BREAK
-#endif
-
-#define MYGUI_EXCEPT(dest) \
-{ \
-	MYGUI_LOG(Critical, dest); \
-	MYGUI_DBG_BREAK;\
-	std::ostringstream stream; \
-	stream << dest << "\n"; \
-	MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
-}
-
-#define MYGUI_ASSERT(exp, dest) \
-{ \
-	if ( ! (exp) ) \
-	{ \
-		MYGUI_LOG(Critical, dest); \
-		MYGUI_DBG_BREAK;\
-		std::ostringstream stream; \
-		stream << dest << "\n"; \
-		MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
-	} \
-}
-
-#define MYGUI_ASSERT_RANGE(index, size, owner) MYGUI_ASSERT(index < size, owner << " : index number " << index << " out of range [" << size << "]");
-#define MYGUI_ASSERT_RANGE_AND_NONE(index, size, owner) MYGUI_ASSERT(index < size || index == ITEM_NONE, owner << " : index number " << index << " out of range [" << size << "]");
-#define MYGUI_ASSERT_RANGE_INSERT(index, size, owner) MYGUI_ASSERT((index <= size) || (index == MyGUI::ITEM_NONE), owner << " : insert index number " << index << " out of range [" << size << "] or not ITEM_NONE");
-
-#if MYGUI_DEBUG_MODE == 1
-	#define MYGUI_REGISTER_VALUE(map, value) \
-	{ \
-		MYGUI_LOG(Info, "Register value : '" << #value << "' = " << (int)value); \
-		map[#value] = value; \
-	}
-	#define MYGUI_DEBUG_ASSERT(exp, dest) MYGUI_ASSERT(exp, dest)
-#else
-	#define MYGUI_REGISTER_VALUE(map, value) map[#value] = value;
-	#define MYGUI_DEBUG_ASSERT(exp, dest) ((void)0)
-#endif
-
-
-// for more info see: http://mdf-i.blogspot.com/2008/09/deprecated-gcc-vs-vs-vs-vs.html
-#if MYGUI_COMPILER == MYGUI_COMPILER_MSVC
-	#if MYGUI_COMP_VER == 1310 	// VC++ 7.1
-		#define MYGUI_OBSOLETE_START(text)
-	    #define MYGUI_OBSOLETE_END
-	#else
-		#define MYGUI_OBSOLETE_START(text) __declspec(deprecated(text))
-	    #define MYGUI_OBSOLETE_END
-	#endif
-
-#elif MYGUI_COMPILER == MYGUI_COMPILER_GNUC
-	#if MYGUI_PLATFORM == MYGUI_PLATFORM_LINUX && MYGUI_COMP_VER == 412
-		#define MYGUI_OBSOLETE_START(text)
-        #define MYGUI_OBSOLETE_END
-	#else
-        #define MYGUI_OBSOLETE_START(text)
-		#define MYGUI_OBSOLETE_END __attribute__((deprecated))
-	#endif
-
-#else
-	#define MYGUI_OBSOLETE_START(text)
-	#define MYGUI_OBSOLETE_END
-
-#endif
-
-#define MYGUI_OBSOLETE(text) /*! \deprecated text */ MYGUI_OBSOLETE_START(text)MYGUI_OBSOLETE_END
-
-#endif // __MYGUI_DIAGNOSTIC_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DynLib.h

@@ -1,111 +0,0 @@
-/*!
-	@file
-	@author		Denis Koronchik
-	@author		Georgiy Evmenov
-	@date		09/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef __MYGUI_DYNLIB_H__
-#define __MYGUI_DYNLIB_H__
-
-#include "MyGUI_Prerequest.h"
-#include <string>
-
-
-#if MYGUI_PLATFORM == MYGUI_PLATFORM_WIN32
-#    define MYGUI_DYNLIB_HANDLE hInstance
-#    define MYGUI_DYNLIB_LOAD( a ) LoadLibrary( a )
-#    define MYGUI_DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )
-#    define MYGUI_DYNLIB_UNLOAD( a ) !FreeLibrary( a )
-
-struct HINSTANCE__;
-typedef struct HINSTANCE__* hInstance;
-
-#elif MYGUI_PLATFORM == MYGUI_PLATFORM_LINUX
-#    define MYGUI_DYNLIB_HANDLE void*
-#    define MYGUI_DYNLIB_LOAD( a ) dlopen( a, RTLD_LAZY | RTLD_GLOBAL)
-#    define MYGUI_DYNLIB_GETSYM( a, b ) dlsym( a, b )
-#    define MYGUI_DYNLIB_UNLOAD( a ) dlclose( a )
-
-#elif MYGUI_PLATFORM == MYGUI_PLATFORM_APPLE
-#    include <CoreFoundation/CFBundle.h>
-#    define MYGUI_DYNLIB_HANDLE CFBundleRef
-#    define MYGUI_DYNLIB_LOAD( a ) mac_loadExeBundle( a )
-#    define MYGUI_DYNLIB_GETSYM( a, b ) mac_getBundleSym( a, b )
-#    define MYGUI_DYNLIB_UNLOAD( a ) mac_unloadExeBundle( a )
-#endif
-
-namespace MyGUI
-{
-
-	/*! @brief Resource holding data about a dynamic library.
-
-		@remarks
-		This class holds the data required to get symbols from
-		libraries loaded at run-time (i.e. from DLL's for so's)
-	*/
-	class MYGUI_EXPORT DynLib
-	{
-		friend class DynLibManager;
-
-	protected:
-		DynLib(const std::string &name);
-
-		~DynLib();
-
-	public:
-
-		/*! Load the library
-		*/
-		bool load();
-
-		/*! Unload the library
-		*/
-		void unload();
-
-		//! Get the name of the library
-		std::string getName(void) const { return mName; }
-
-		/**
-			Returns the address of the given symbol from the loaded library.
-			@param
-				strName The name of the symbol to search for
-			@returns
-				If the function succeeds, the returned value is a handle to the symbol.
-				If the function fails, the returned value is <b>nullptr</b>.
-		*/
-		void* getSymbol( const std::string& strName ) const throw();
-
-	protected:
-		//! Gets the last loading error
-		std::string dynlibError(void);
-
-
-	protected:
-		//!	Name of library
-		std::string mName;
-
-		//! Handle to the loaded library.
-		MYGUI_DYNLIB_HANDLE mInstance;
-	};
-
-}
-
-#endif // __MYGUI_DYNLIB_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_DynLibManager.h

@@ -1,58 +0,0 @@
-/*!
-	@file
-	@author		Denis Koronchik
-	@date		08/2007
-	@module		libEngine
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_DYN_LIB_MANAGER_H__
-#define __MYGUI_DYN_LIB_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_DynLib.h"
-#include <map>
-
-namespace MyGUI
-{
-
-	/*!	\brief Manager of dynamic libraries
-	*/
-	class MYGUI_EXPORT DynLibManager
-	{
-		MYGUI_INSTANCE_HEADER( DynLibManager )
-
-	public:
-		void initialise();
-		void shutdown();
-
-		//!	Load library
-		DynLib* load(const std::string &fileName);
-		//!	Unload library
-		void unload(DynLib *library);
-
-	private:
-		//! Dynamic libraries map
-		typedef std::map <std::string, DynLib*> StringDynLibMap;
-		//!	Loaded libraries
-		StringDynLibMap mLibsMap;
-	};
-
-}
-
-#endif // __MYGUI_DYN_LIB_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Edit.h

@@ -1,443 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_EDIT_H__
-#define __MYGUI_EDIT_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_StaticText.h"
-#include "MyGUI_TextChangeHistory.h"
-#include "MyGUI_TextIterator.h"
-#include "MyGUI_EventPair.h"
-#include "MyGUI_ScrollViewBase.h"
-
-namespace MyGUI
-{
-
-	typedef delegates::CDelegate1<Edit*> EventHandle_EditPtr;
-
-	class MYGUI_EXPORT Edit :
-		public StaticText,
-		public ScrollViewBase
-	{
-		MYGUI_RTTI_DERIVED( Edit )
-
-	public:
-		Edit();
-
-		/** Colour interval */
-		void setTextIntervalColour(size_t _start, size_t _count, const Colour& _colour);
-
-		/** Get index of first selected character or ITEM_NONE if nothing selected */
-		size_t getTextSelectionStart();
-
-		/** Get index of last selected character or ITEM_NONE if nothing selected */
-		size_t getTextSelectionEnd();
-
-		/** Get length of selected text */
-		size_t getTextSelectionLength();
-
-		// возвращает текст с тегами
-		/** Get _count characters with tags from _start position */
-		UString getTextInterval(size_t _start, size_t _count);
-
-		/** Set selected text interval
-			@param _start of interval
-			@param _end of interval
-		*/
-		void setTextSelection(size_t _start, size_t _end);
-
-		/** Delete selected text */
-		void deleteTextSelection();
-
-		/** Get selected text */
-		UString getTextSelection();
-
-		/** Is any text selected */
-		bool isTextSelection();
-
-		/** Colour selected text */
-		void setTextSelectionColour(const Colour& _value);
-
-		/** Set text cursor position */
-		void setTextCursor(size_t _index);
-		/** Get text cursor position */
-		size_t getTextCursor() { return mCursorPosition; }
-
-
-		/** Set edit text applying tags */
-		virtual void setCaption(const UString& _value);
-		/** Get edit text with tags */
-		virtual const UString& getCaption();
-
-		/** Set edit text without tags */
-		void setOnlyText(const UString& _value);
-		/** Get edit text without tags */
-		UString getOnlyText();
-
-		/** Get text length excluding tags
-			For example "#00FF00Hello" length is 5
-		*/
-		size_t getTextLength() const { return mTextLength; }
-
-		//! Sets if surplus characters should push characters off the left side rather than ignored
-		void setOverflowToTheLeft(bool _value) { mOverflowToTheLeft = _value; }
-		//! Returns true if surplus characters will be pushed off the left rather than ignored
-		bool getOverflowToTheLeft() { return mOverflowToTheLeft; }
-
-		//! Sets the max amount of text allowed in the edit field.
-		void setMaxTextLength(size_t _value) { mMaxTextLength = _value; }
-		//! Gets the max amount of text allowed in the edit field.
-		size_t getMaxTextLength() { return mMaxTextLength; }
-
-		/** Inser text at _index position (text end by default) */
-		void insertText(const UString& _text, size_t _index = ITEM_NONE);
-		/** Add text */
-		void addText(const UString& _text);
-		/** Erase _count characters from _start position */
-		void eraseText(size_t _start, size_t _count = 1);
-
-		/** Enable or disable edit read only mode\n
-			Read only mode: you can't edit text, but can select it.\n
-			Disabled (false) by default.
-		*/
-		void setEditReadOnly(bool _value);
-		/** Get edit read only mode flag */
-		bool getEditReadOnly() { return mModeReadOnly; }
-
-		/** Enable or disable edit password mode\n
-			Password mode: you see password chars (*** by default) instead text.\n
-			Disabled (false) by default.
-		*/
-		void setEditPassword(bool _value);
-		/** Get edit password mode flag */
-		bool getEditPassword() { return mModePassword; }
-
-		/** Enable or disable edit multiline mode\n
-			Multile mode: new line character moves text to new line.\n
-			Otherwise new lines replaced with space and all text is in single line.\n
-			Disabled (false) by default.
-		*/
-		void setEditMultiLine(bool _value);
-		/** Get edit multiline mode flag */
-		bool getEditMultiLine() { return mModeMultiline; }
-
-		/** Enable or disable edit static mode\n
-			Static mode is same as read only, but you also can't select text.\n
-			Disabled (false) by default.
-		*/
-		void setEditStatic(bool _value);
-		/** Get edit static mode flag */
-		bool getEditStatic() { return mModeStatic; }
-
-		/** Set edit password character ('*' by default) */
-		void setPasswordChar(Char _value);
-		/** Set edit password character ('*' by default). First character of string used. */
-		void setPasswordChar(const UString& _char);
-		/** Get edit password character */
-		Char getPasswordChar() { return mCharPassword; }
-
-		/** Enable or disable edit word wrap mode\n
-			Word Wrap mode: move words to new line if they goes out of width.
-			Also in this mode you can't edit or select text.\n
-			Disabled (false) by default.
-		*/
-		void setEditWordWrap(bool _value);
-		/** Get edit word wrap mode flag */
-		bool getEditWordWrap() { return mModeWordWrap; }
-
-		/** Enable or disable tab printing mode\n
-			Tab printing mode: when editing text and pressing Tab key it displayed.
-			If this mode disabled Tab key ignored.\n
-			Disabled (false) by default.
-		*/
-		void setTabPrinting(bool _value) { mTabPrinting = _value; }
-		/** Get edit tab printing wrap mode flag */
-		bool getTabPrinting() { return mTabPrinting; }
-
-		/** Get invert selected text color property */
-		bool getInvertSelected();
-		/** Enable or disable inverting color of selected text\n
-			Enabled (true) by default
-		*/
-		void setInvertSelected(bool _value);
-
-		//! @copydoc Widget::setPosition(const IntPoint& _value)
-		virtual void setPosition(const IntPoint& _value);
-		//! @copydoc Widget::setSize(const IntSize& _value)
-		virtual void setSize(const IntSize& _value);
-		//! @copydoc Widget::setCoord(const IntCoord& _value)
-		virtual void setCoord(const IntCoord& _value);
-
-		/** @copydoc Widget::setPosition(int _left, int _top) */
-		void setPosition(int _left, int _top) { setPosition(IntPoint(_left, _top)); }
-		/** @copydoc Widget::setSize(int _width, int _height) */
-		void setSize(int _width, int _height) { setSize(IntSize(_width, _height)); }
-		/** @copydoc Widget::setCoord(int _left, int _top, int _width, int _height) */
-		void setCoord(int _left, int _top, int _width, int _height) { setCoord(IntCoord(_left, _top, _width, _height)); }
-
-		/** Show VScroll when text size larger than Edit */
-		void setVisibleVScroll(bool _value);
-		/** Get Show VScroll flag */
-		bool isVisibleVScroll() { return mVisibleVScroll; }
-		/** Get range of vertical scroll (or 0 if no scroll).
-			Range measured in pixels (full text heiht minus Edit height).
-			For example if Edit is 200 pixels height and 40 lines of text
-			30 pixels height each (i.e. 600 pixels total), then return
-			value is 400 ( = 600 - 200 ).
-		*/
-		size_t getVScrollRange();
-		/** Get current position of vertical scroll (or 0 if no scroll) */
-		size_t getVScrollPosition();
-		/** Set current position of vertical scroll */
-		void setVScrollPosition(size_t _index);
-
-		/** Show HScroll when text size larger than Edit */
-		void setVisibleHScroll(bool _value);
-		/** Get Show HScroll flag */
-		bool isVisibleHScroll() { return mVisibleHScroll; }
-		/** Get range of horizontal scroll (or 0 if no scroll).
-			Range measured in pixels (full text width minus Edit width).
-			For example if Edit is 200 pixels width and the longest line
-			is 600 pixels width, then return value is 400 ( = 600 - 200 ).
-		*/
-		size_t getHScrollRange();
-		/** Get current position of horizontal scroll (or 0 if no scroll) */
-		size_t getHScrollPosition();
-		/** Set current position of horizontal scroll */
-		void setHScrollPosition(size_t _index);
-
-
-		//! @copydoc StaticText::setFontName
-		virtual void setFontName(const std::string& _value);
-		//! @copydoc StaticText::setFontHeight
-		virtual void setFontHeight(int _value);
-
-		//! @copydoc StaticText::setTextAlign
-		virtual void setTextAlign(Align _value);
-
-		/** @copydoc Widget::setProperty(const std::string& _key, const std::string& _value) */
-		virtual void setProperty(const std::string& _key, const std::string& _value);
-
-	/*event:*/
-		/** Event : Enter pressed (Ctrl+enter in multiline mode).\n
-			signature : void method(MyGUI::Edit* _sender)
-			@param _sender widget that called this event
-		*/
-		EventPair<EventHandle_WidgetVoid, EventHandle_EditPtr> eventEditSelectAccept;
-
-		/** Event : Text changed.\n
-			signature : void method(MyGUI::Edit* _sender)
-			@param _sender widget that called this event
-		*/
-		EventPair<EventHandle_WidgetVoid, EventHandle_EditPtr> eventEditTextChange;
-
-	/*internal:*/
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-	/*obsolete:*/
-#ifndef MYGUI_DONT_USE_OBSOLETE
-
-		MYGUI_OBSOLETE("use : void Edit::setVisibleVScroll(bool _visible)")
-		void showVScroll(bool _visible) { setVisibleVScroll(_visible); }
-		MYGUI_OBSOLETE("use : bool Edit::isVisibleVScroll()")
-		bool isShowVScroll() { return isVisibleVScroll(); }
-		MYGUI_OBSOLETE("use : void Edit::setVisibleHScroll(bool _visible)")
-		void showHScroll(bool _visible) { setVisibleHScroll(_visible); }
-		MYGUI_OBSOLETE("use : bool Edit::isVisibleHScroll()")
-		bool isShowHScroll() { return isVisibleHScroll(); }
-
-		MYGUI_OBSOLETE("use : void Widget::setCoord(const IntCoord& _coord)")
-		void setPosition(const IntCoord& _coord) { setCoord(_coord); }
-		MYGUI_OBSOLETE("use : void Widget::setCoord(int _left, int _top, int _width, int _height)")
-		void setPosition(int _left, int _top, int _width, int _height) { setCoord(_left, _top, _width, _height); }
-
-		// to avoid hiding base virtual function
-		virtual void setTextColour(const Colour& _colour) { Base::setTextColour(_colour); }
-
-		MYGUI_OBSOLETE("use : void Edit::setTextIntervalColour(size_t _start, size_t _count, const Colour& _colour)")
-		void setTextColour(size_t _start, size_t _count, const Colour& _colour) { setTextIntervalColour(_start, _count, _colour); }
-
-		MYGUI_OBSOLETE("use : size_t Edit::getTextSelectionStart() , size_t getTextSelectionEnd()")
-		void getTextSelect(size_t& _start, size_t& _end);
-
-		MYGUI_OBSOLETE("use : UString Edit::getTextInterval(size_t _start, size_t _count)")
-		UString getText(size_t _start, size_t _count) { return getTextInterval(_start, _count); }
-
-		MYGUI_OBSOLETE("use : void Edit::setTextSelection(size_t _start, size_t _end)")
-		void setTextSelect(size_t _start, size_t _end) { setTextSelection(_start, _end); }
-
-		MYGUI_OBSOLETE("use : void Edit::deleteTextSelection()")
-		void deleteTextSelect() { deleteTextSelection(); }
-
-		MYGUI_OBSOLETE("use : UString Edit::getTextSelection()")
-		UString getSelectedText() { return getTextSelection(); }
-
-		MYGUI_OBSOLETE("use : bool Edit::isTextSelection()")
-		bool isTextSelect() { return isTextSelection(); }
-
-		MYGUI_OBSOLETE("use : void Edit::setTextSelectionColour(const Colour& _colour)")
-		void setTextSelectColour(const Colour& _colour) { setTextSelectionColour(_colour); }
-
-#endif // MYGUI_DONT_USE_OBSOLETE
-
-
-	protected:
-		virtual ~Edit();
-
-		virtual void onMouseDrag(int _left, int _top);
-		virtual void onKeyLostFocus(Widget* _new);
-		virtual void onKeySetFocus(Widget* _old);
-		virtual void onKeyButtonPressed(KeyCode _key, Char _char);
-
-		// потом убрать все нотифи в сраку
-		void notifyMouseSetFocus(Widget* _sender, Widget* _old);
-		void notifyMouseLostFocus(Widget* _sender, Widget* _new);
-		void notifyMousePressed(Widget* _sender, int _left, int _top, MouseButton _id);
-		void notifyMouseReleased(Widget* _sender, int _left, int _top, MouseButton _id);
-		void notifyMouseDrag(Widget* _sender, int _left, int _top);
-		void notifyMouseButtonDoubleClick(Widget* _sender);
-
-		void notifyScrollChangePosition(VScroll* _sender, size_t _position);
-		void notifyMouseWheel(Widget* _sender, int _rel);
-
-		// обновление представления
-		void updateView();
-		void updateViewWithCursor();
-
-		void baseChangeWidgetSkin(ResourceSkin* _info);
-
-		void eraseView();
-
-	private:
-		void initialiseWidgetSkin(ResourceSkin* _info);
-		void shutdownWidgetSkin();
-
-	private:
-		// устанавливает текст
-		void setText(const UString& _text, bool _history);
-		// удаляет все что выделенно
-		bool deleteTextSelect(bool _history);
-		// вставляет текст в указанную позицию
-		void insertText(const UString& _text, size_t _index, bool _history);
-		// удаляет текст
-		void eraseText(size_t _start, size_t _count, bool _history);
-		// выделяет цветом выделение
-		void setTextSelectColour(const Colour& _colour, bool _history);
-		// выделяет цветом диапазон
-		void _setTextColour(size_t _start, size_t _count, const Colour& _colour, bool _history);
-
-		void frameEntered(float _frame);
-
-		void updateEditState();
-
-		// обновляет курсор по координате
-		void updateSelectText();
-
-		void resetSelect();
-
-		// запись в историю данных о позиции
-		void commandPosition(size_t _undo, size_t _redo, size_t _length, VectorChangeInfo * _info = nullptr);
-
-		// команнды отмена и повтор
-		bool commandRedo();
-		bool commandUndo();
-		// объединяет последние две комманды
-		void commandMerge();
-		// очистка
-		void commandResetRedo() { mVectorRedoChangeInfo.clear(); }
-		void commandResetHistory() { mVectorRedoChangeInfo.clear();mVectorUndoChangeInfo.clear(); }
-		void saveInHistory(VectorChangeInfo * _info = nullptr);
-
-		// работа с буфером обмена
-		void commandCut();
-		void commandCopy();
-		void commandPast();
-
-		const UString& getRealString();
-
-		void setRealString(const UString& _caption);
-
-		void updateCursorPosition();
-
-		// размер данных
-		virtual IntSize getContentSize();
-		// смещение данных
-		virtual IntPoint getContentPosition();
-		virtual void setContentPosition(const IntPoint& _point);
-		// размер окна, через которые видно данные
-		virtual IntSize getViewSize() const;
-		// размер на который прокручиваются данные при щелчке по скролу
-		virtual size_t getVScrollPage();
-		virtual size_t getHScrollPage();
-
-		virtual Align getContentAlign();
-
-	protected:
-		// нажата ли кнопка
-		bool mIsPressed;
-		// в фокусе ли кнопка
-		bool mIsFocus;
-
-		bool mCursorActive;
-		float mCursorTimer;
-		float mActionMouseTimer;
-
-		// позиция курсора
-		size_t mCursorPosition;
-		// максимальное колличество
-		size_t mTextLength;
-
-		// выделение
-		size_t mStartSelect;
-		size_t mEndSelect;
-
-		// списоки изменений для отмены и повтора
-		DequeUndoRedoInfo mVectorUndoChangeInfo;
-		DequeUndoRedoInfo mVectorRedoChangeInfo;
-
-		bool mMouseLeftPressed;
-
-		bool mModeReadOnly;
-		bool mModePassword;
-		bool mModeMultiline;
-		bool mModeStatic;
-		bool mModeWordWrap;
-
-		bool mTabPrinting;
-
-		// настоящий текст, закрытый за звездочками
-		UString mPasswordText;
-
-		// для поддержки режима статик, где курсор не нужен
-		std::string mOriginalPointer;
-
-		Char mCharPassword;
-
-		bool mOverflowToTheLeft;
-		size_t mMaxTextLength;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_EDIT_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_EditText.h

@@ -1,164 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		09/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_EDIT_TEXT_H__
-#define __MYGUI_EDIT_TEXT_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_XmlDocument.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_ISubWidgetText.h"
-#include "MyGUI_IFont.h"
-#include "MyGUI_ResourceSkin.h"
-#include "MyGUI_RenderFormat.h"
-#include "MyGUI_TextView.h"
-
-namespace MyGUI
-{
-
-	class RenderItem;
-
-	class MYGUI_EXPORT EditText : public ISubWidgetText
-	{
-		MYGUI_RTTI_DERIVED( EditText )
-
-	public:
-		EditText();
-		virtual ~EditText();
-
-		virtual void setVisible(bool _value);
-
-		// обновляет все данные связанные с тектом
-		virtual void updateRawData();
-
-		// метод для отрисовки себя
-		virtual void doRender();
-
-		void setCaption(const UString& _value);
-		const UString& getCaption();
-
-		void setTextColour(const Colour& _value);
-		const Colour& getTextColour();
-
-		void setAlpha(float _value);
-		float getAlpha();
-
-		virtual void setFontName(const std::string& _value);
-		virtual const std::string& getFontName();
-
-		virtual void setFontHeight(int _value);
-		virtual int getFontHeight();
-
-		virtual void createDrawItem(ITexture* _texture, ILayerNode * _node);
-		virtual void destroyDrawItem();
-
-		virtual void setTextAlign(Align _value);
-		virtual Align getTextAlign();
-
-		virtual size_t getTextSelectionStart();
-		virtual size_t getTextSelectionEnd();
-		virtual void setTextSelection(size_t _start, size_t _end);
-
-		virtual bool getSelectBackground();
-		virtual void setSelectBackground(bool _normal);
-
-		virtual bool isVisibleCursor();
-		virtual void setVisibleCursor(bool _value);
-
-		/** Get invert selected text color property */
-		virtual bool getInvertSelected() { return mInvertSelect; }
-		/** Enable or disable inverting color of selected text\n
-			Enabled (true) by default
-		*/
-		virtual void setInvertSelected(bool _value);
-
-		virtual size_t getCursorPosition();
-		virtual void setCursorPosition(size_t _index);
-
-		virtual IntSize getTextSize();
-
-		// устанавливает смещение текста в пикселях
-		virtual void setViewOffset(const IntPoint& _point);
-		virtual IntPoint getViewOffset();
-
-		// возвращает положение курсора по произвольному положению
-		virtual size_t getCursorPosition(const IntPoint& _point);
-
-		// возвращает положение курсора в обсолютных координатах
-		virtual IntCoord getCursorCoord(size_t _position);
-
-		void setShiftText(bool _shift);
-
-		void setWordWrap(bool _value);
-
-		virtual void setStateData(IStateInfo * _data);
-
-		void _updateView();
-		void _correctView();
-
-	/*internal:*/
-		void _setAlign(const IntSize& _oldsize, bool _update);
-		void _setAlign(const IntCoord& _oldcoord, bool _update);
-
-	protected:
-		bool mEmptyView;
-		uint32 mCurrentColour;
-		uint32 mInverseColour;
-		uint32 mCurrentAlpha;
-		IntCoord mCurrentCoord;
-
-		UString mCaption;
-		bool mTextOutDate;
-		Align mTextAlign;
-
-		Colour mColour;
-		float mAlpha;
-		VertexColourType mVertexFormat;
-
-		IFont* mFont;
-		ITexture* mTexture;
-		int mFontHeight;
-
-		bool mBackgroundNormal;
-		size_t mStartSelect;
-		size_t mEndSelect;
-		size_t mCursorPosition;
-		bool mVisibleCursor;
-		bool mInvertSelect;
-
-		IntPoint mViewOffset; // смещение текста
-
-		ILayerNode* mNode;
-		RenderItem* mRenderItem;
-		size_t mCountVertex;
-		bool mIsAddCursorWidth;
-
-		bool mShiftText;
-		bool mWordWrap;
-		int mOldWidth;
-
-		TextView mTextView;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_EDIT_TEXT_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Enumerator.h

@@ -1,108 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		08/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ENUMERATOR_H__
-#define __MYGUI_ENUMERATOR_H__
-
-#include <assert.h>
-
-namespace MyGUI
-{
-
-	/** Class for comfortable using of vectors with small while loop
-	instead iterators. Performance is same as with iterators.
-	Enumerator usage
-	@example Enumerator
-	@code
-		typedef std::vector<std::string> VectorString;
-		typedef Enumerator<VectorString> EnumeratorVectorString;
-
-		VectorString vec;
-		vec.push_back("value");
-		//EnumeratorVectorString enum_vec(vec.begin(), vec.end());
-		EnumeratorVectorString enum_vec(vec);
-		while (enum_vec.next())
-		{
-			std::string value = enum_vec.current();
-		}
-
-		typedef std::pair<std::string, std::string> PairString;
-		typedef std::map<PairString> MapString;
-
-		MapString map;
-		map["key"] = "value";
-		//EnumeratorMapString enum_map(map.begin(), map.end());
-		EnumeratorMapString enum_map(map);
-		while (enum_map.next())
-		{
-			std::string key = enum_map.current().first;
-			std::string value = enum_map.current().second;
-		}
-	@endcode
-	*/
-
-	template<typename T>
-	class Enumerator
-	{
-	private:
-		Enumerator() { }
-
-	public:
-		explicit Enumerator(const T& _container) :
-			m_first(true),
-			m_current(_container.begin()),
-			m_end(_container.end())
-		{
-		}
-
-		Enumerator(typename T::const_iterator _first, typename T::const_iterator _end) :
-			m_first(true),
-			m_current(_first),
-			m_end(_end)
-		{
-		}
-
-		bool next()
-		{
-			if (m_current == m_end) return false;
-			else if (m_first)
-			{
-				m_first = false;
-				return true;
-			}
-			++ m_current;
-			if (m_current == m_end) return false;
-			return true;
-		}
-
-		typename T::const_reference operator->() const { assert(m_current != m_end); return (*m_current); }
-		typename T::const_reference current() { assert(m_current != m_end); return (*m_current); }
-
-	private:
-		bool m_first;
-		typename T::const_iterator m_current;
-		typename T::const_iterator m_end;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ENUMERATOR_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_EventPair.h

@@ -1,118 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		10/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_EVENT_PAIR_H__
-#define __MYGUI_EVENT_PAIR_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	template <typename EventObsolete, typename Event>
-	class EventPair
-	{
-	public:
-
-		template <typename T>
-		MYGUI_OBSOLETE("use : signature : Event::IDelegate * _delegate")
-		void operator = (T * _delegate)
-		{
-			m_eventObsolete = _delegate;
-			m_event = nullptr;
-		}
-
-		void operator = (typename Event::IDelegate * _delegate)
-		{
-			m_eventObsolete = nullptr;
-			m_event = _delegate;
-		}
-
-		template <typename TP1>
-		void operator()( TP1 p1 )
-		{
-			m_eventObsolete(p1);
-			m_event(p1);
-		}
-
-		template <typename TP1, typename TP2>
-		void operator()( TP1 p1, TP2 p2 )
-		{
-			m_eventObsolete(p1, p2);
-			m_event(p1, p2);
-		}
-
-		template <typename TP1, typename TP2, typename TP3>
-		void operator()( TP1 p1, TP2 p2, TP3 p3 )
-		{
-			m_eventObsolete(p1, p2, p3);
-			m_event(p1, p2, p3);
-		}
-
-		template <typename TP1, typename TP2, typename TP3, typename TP4>
-		void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4 )
-		{
-			m_eventObsolete(p1, p2, p3, p4);
-			m_event(p1, p2, p3, p4);
-		}
-
-		template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5>
-		void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5 )
-		{
-			m_eventObsolete(p1, p2, p3, p4, p5);
-			m_event(p1, p2, p3, p4, p5);
-		}
-
-		template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6>
-		void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6 )
-		{
-			m_eventObsolete(p1, p2, p3, p4, p5, p6);
-			m_event(p1, p2, p3, p4, p5, p6);
-		}
-
-		template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6, typename TP7>
-		void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6, TP7 p7 )
-		{
-			m_eventObsolete(p1, p2, p3, p4, p5, p6, p7);
-			m_event(p1, p2, p3, p4, p5, p6, p7);
-		}
-
-		template <typename TP1, typename TP2, typename TP3, typename TP4, typename TP5, typename TP6, typename TP7, typename TP8>
-		void operator()( TP1 p1, TP2 p2, TP3 p3, TP4 p4, TP5 p5, TP6 p6, TP7 p7, TP8 p8 )
-		{
-			m_eventObsolete(p1, p2, p3, p4, p5, p6, p7, p8);
-			m_event(p1, p2, p3, p4, p5, p6, p7, p8);
-		}
-
-		bool empty() const
-		{
-			return m_eventObsolete.empty() && m_event.empty();
-		}
-
-	public:
-		EventObsolete m_eventObsolete;
-		Event m_event;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_EVENT_PAIR_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Exception.h

@@ -1,69 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		05/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_EXCEPTION_H__
-#define __MYGUI_EXCEPTION_H__
-
-#include "MyGUI_Prerequest.h"
-#include <exception>
-#include <string>
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT Exception : public std::exception
-	{
-	protected:
-		std::string mDescription;
-		std::string mSource;
-		std::string mFile;
-		long mLine;
-		mutable std::string mFullDesc;
-
-	public:
-		Exception(const std::string& _description, const std::string& _source, const char* _file, long _line );
-
-		Exception(const Exception& _rhs);
-
-		// Needed for  compatibility with std::exception
-		~Exception() throw() { }
-
-		Exception& operator = (const Exception& _rhs);
-
-		virtual const std::string& getFullDescription() const;
-
-		virtual const std::string &getSource() const { return mSource; }
-
-		virtual const std::string &getFile() const { return mFile; }
-
-		virtual long getLine() const { return mLine; }
-
-		virtual const std::string& getDescription() const { return mDescription; }
-
-		// Override std::exception::what
-		const char* what() const throw() { return getFullDescription().c_str(); }
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_EXCEPTION_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FactoryManager.h

@@ -1,79 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		06/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_FACTORY_MANAGER_H__
-#define __MYGUI_FACTORY_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_IObject.h"
-#include "MyGUI_GenericFactory.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT FactoryManager
-	{
-		MYGUI_INSTANCE_HEADER( FactoryManager )
-
-	public:
-		typedef delegates::CDelegate1<IObject*&> Delegate;
-
-		void initialise();
-		void shutdown();
-
-		void registerFactory(const std::string& _category, const std::string& _type, Delegate::IDelegate* _delegate);
-		void unregisterFactory(const std::string& _category, const std::string& _type);
-		void unregisterFactory(const std::string& _category);
-
-		bool isFactoryExist(const std::string& _category, const std::string& _type);
-
-		template<typename Type>
-		void registerFactory(const std::string& _category)
-		{
-			registerFactory(_category, Type::getClassTypeName(), GenericFactory<Type>::getFactory());
-		}
-
-		template<typename Type>
-		void registerFactory(const std::string& _category, const std::string& _type)
-		{
-			registerFactory(_category, _type, GenericFactory<Type>::getFactory());
-		}
-
-		template<typename Type>
-		void unregisterFactory(const std::string& _category)
-		{
-			unregisterFactory(_category, Type::getClassTypeName());
-		}
-
-		IObject* createObject(const std::string& _category, const std::string& _type);
-		void destroyObject(IObject* _object);
-
-	private:
-		typedef std::map<std::string, Delegate> MapFactoryItem;
-		typedef std::map<std::string, MapFactoryItem> MapRegisterFactoryItem;
-		MapRegisterFactoryItem mRegisterFactoryItems;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_FACTORY_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FontData.h

@@ -1,129 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		06/2009
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_FONT_DATA_H__
-#define __MYGUI_FONT_DATA_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	struct MYGUI_EXPORT FontCodeType
-	{
-		enum Enum
-		{
-			Selected = 6,
-			SelectedBack = 7,
-			Cursor = 8,
-			Tab = 9,
-			LF = 0x000A,
-			CR = 0x000D,
-			Space = 0x0020,
-			LatinStart = 0x0021,
-			NEL = 0x0085,
-			LatinEnd = 0x00A6,
-			MAX
-		};
-
-		FontCodeType(Enum _value = MAX) : value(_value) { }
-
-		friend bool operator == (FontCodeType const& a, FontCodeType const& b) { return a.value == b.value; }
-		friend bool operator != (FontCodeType const& a, FontCodeType const& b) { return a.value != b.value; }
-
-	private:
-		Enum value;
-	};
-
-	// èíôîðìàöèÿ îá îäíîì ñèìâîëå
-	struct GlyphInfo
-	{
-		FloatRect uvRect;
-		Char codePoint;
-		int width;
-
-		GlyphInfo() : codePoint(0), width(0) { }
-	};
-
-	typedef std::vector<GlyphInfo> VectorGlyphInfo;
-
-	// èíôîðìàöèÿ îá äèàïàçîíå
-	//FIXME move to std::pair
-	class PairCodePoint
-	{
-	public:
-		PairCodePoint() : first(0), last(0) { }
-		PairCodePoint(Char _first, Char _last) : first(_first), last(_last) { }
-
-		// ïðîâåðÿåò âõîäèò ëè ñèìâîë â äèàïàçîí
-		bool isExist(Char _code) const { return _code >= first && _code <= last; }
-
-	public:
-		Char first;
-		Char last;
-	};
-
-	// èíôîìàöèÿ î äèàïàçîíå ñèìâîëîâ
-	class RangeInfo
-	{
-	public:
-		RangeInfo() : first(0), last(0) { }
-		RangeInfo(Char _first, Char _last) :
-			first(_first),
-			last(_last)
-		{
-			range.resize(last - first + 1);
-		}
-
-		// ïðîâåðÿåò âõîäèò ëè ñèìâîë â äèàïàçîí
-		bool isExist(Char _code) const { return _code >= first && _code <= last; }
-
-		// âîçâðàùàåò óêàçàòåëü íà ãëèô, èëè 0, åñëè êîä íå âõîäèò â äèàïàçîí
-		GlyphInfo* getInfo(Char _code) { return isExist(_code) ? &range[_code - first] : nullptr; }
-		void setInfo(Char _code, GlyphInfo* _value) { if (isExist(_code)) range[_code - first] = *_value; }
-
-	public:
-		Char first;
-		Char last;
-		VectorGlyphInfo range;
-	};
-
-	// FIXME move to resource font
-	class PairCodeCoord
-	{
-	public:
-		PairCodeCoord() : code(0) { }
-		PairCodeCoord(Char _code, const IntCoord& _coord) :
-			code(_code),
-			coord(_coord)
-		{
-		}
-
-		bool operator < (const PairCodeCoord& _value) const { return code < _value.code; }
-
-		Char code;
-		IntCoord coord;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_FONT_DATA_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_FontManager.h

@@ -1,60 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_FONT_MANAGER_H__
-#define __MYGUI_FONT_MANAGER_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Enumerator.h"
-#include "MyGUI_IFont.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_XmlDocument.h"
-#include "MyGUI_ResourceManager.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT FontManager
-	{
-		MYGUI_INSTANCE_HEADER( FontManager )
-
-	public:
-		void initialise();
-		void shutdown();
-
-		/** Load additional MyGUI *_font.xml file */
-		bool load(const std::string& _file);
-		void _load(xml::ElementPtr _node, const std::string& _file, Version _version);
-
-		const std::string& getDefaultFont() const { return mDefaultName; }
-		void setDefaultFont(const std::string& _value);
-
-		/** Get font resource */
-		IFont* getByName(const std::string& _name) const;
-
-	private:
-		std::string mDefaultName;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_FONT_MANAGER_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_GenericFactory.h

@@ -1,36 +0,0 @@
-/*!
-    @file
-    @author     Albert Semenov
-    @date       06/2009
-    @module
-*/
-#ifndef __MYGUI_GENERIC_FACTORY_H__
-#define __MYGUI_GENERIC_FACTORY_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_Delegate.h"
-
-namespace MyGUI
-{
-
-	template <typename Type>
-	class GenericFactory
-	{
-	public:
-		typedef delegates::CDelegate1<IObject*&> Delegate;
-		static typename Delegate::IDelegate* getFactory()
-		{
-			return newDelegate(createFromFactory);
-		}
-
-	private:
-		static void createFromFactory(IObject*& _instance)
-		{
-			_instance = new Type();
-		}
-	};
-
-}
-
-#endif // __MYGUI_GENERIC_FACTORY_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Gui.h

@@ -1,287 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_GUI_H__
-#define __MYGUI_GUI_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-#include "MyGUI_Instance.h"
-#include "MyGUI_XmlDocument.h"
-#include "MyGUI_IWidgetCreator.h"
-#include "MyGUI_IUnlinkWidget.h"
-#include "MyGUI_Widget.h"
-
-namespace MyGUI
-{
-
-	typedef delegates::CMultiDelegate1<float> FrameEventDelegate;
-
-	class MYGUI_EXPORT Gui : public IWidgetCreator, public IUnlinkWidget
-	{
-		friend class WidgetManager;
-		MYGUI_INSTANCE_HEADER( Gui )
-
-	public:
-		/** Initialise GUI and all GUI Managers
-			@param
-				_core name of core config file for MyGUI (contain main config files with skins, layers, fonts, etc.)
-			@param
-				_logFileName Log file name
-		*/
-		void initialise(const std::string& _core = "core.xml", const std::string& _logFileName = MYGUI_LOG_FILENAME);
-
-		/** Shutdown GUI and all GUI Managers*/
-		void shutdown();
-
-		// methods for creating widgets
-		/** Create widget
-			@param _type widget type
-			@param _skin widget skin
-			@param _coord int coordinates of widget (_left, _top, _width, _height)
-			@param _align widget align (possible values can be found in enum Align)
-			@param _layer layer where widget will be created (all layers usually defined in core.layer file).
-				If your widget will overlap with any other you shoud select _layer with "overlapped" property enabled.
-			@param _name if needed (you can use it for finding widget by name later)
-		*/
-		Widget* createWidgetT(const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return baseCreateWidget(WidgetStyle::Overlapped, _type, _skin, _coord, _align, _layer, _name);
-		}
-		/** See Gui::createWidgetT */
-		Widget* createWidgetT(const std::string& _type, const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return createWidgetT(_type, _skin, IntCoord(_left, _top, _width, _height), _align, _layer, _name);
-		}
-		/** Create widget using coordinates relative to parent. see Gui::createWidgetT */
-		Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return createWidgetT(_type, _skin, IntCoord((int)(_coord.left*mViewSize.width), (int)(_coord.top*mViewSize.height), (int)(_coord.width*mViewSize.width), (int)(_coord.height*mViewSize.height)), _align, _layer, _name);
-		}
-		/** Create widget using coordinates relative to parent. see Gui::createWidgetT */
-		Widget* createWidgetRealT(const std::string& _type, const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return createWidgetT(_type, _skin, IntCoord((int)(_left*mViewSize.width), (int)(_top*mViewSize.height), (int)(_width*mViewSize.width), (int)(_height*mViewSize.height)), _align, _layer, _name);
-		}
-
-		// templates for creating widgets by type
-		/** Same as Gui::createWidgetT but return T* instead of Widget* */
-		template <typename T>
-		T* createWidget(const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, _coord, _align, _layer, _name));
-		}
-		/** Same as Gui::createWidgetT but return T* instead of Widget* */
-		template <typename T>
-		T* createWidget(const std::string& _skin, int _left, int _top, int _width, int _height, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return static_cast<T*>(createWidgetT(T::getClassTypeName(), _skin, IntCoord(_left, _top, _width, _height), _align, _layer, _name));
-		}
-		/** Same as Gui::createWidgetRealT but return T* instead of Widget* */
-		template <typename T>
-		T* createWidgetReal(const std::string& _skin, const FloatCoord& _coord, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _coord, _align, _layer, _name));
-		}
-		/** Same as Gui::createWidgetRealT but return T* instead of Widget* */
-		template <typename T>
-		T* createWidgetReal(const std::string& _skin, float _left, float _top, float _width, float _height, Align _align, const std::string& _layer, const std::string& _name = "")
-		{
-			return static_cast<T*>(createWidgetRealT(T::getClassTypeName(), _skin, _left, _top, _width, _height, _align, _layer, _name));
-		}
-
-		/** Get view size of GUI area */
-		const IntSize& getViewSize() const { return mViewSize; }
-
-		int getViewWidth() { return mViewSize.width; }
-		int getViewHeight() { return mViewSize.height; }
-
-		// mirror of InputManager methods
-		/** Inject MouseMove event
-			@return true if event has been processed by GUI
-		*/
-		bool injectMouseMove(int _absx, int _absy, int _absz);
-		/** Inject MousePress event
-			@return true if event has been processed by GUI
-		*/
-		bool injectMousePress(int _absx, int _absy, MouseButton _id);
-		/** Inject MouseRelease event
-			@return true if event has been processed by GUI
-		*/
-		bool injectMouseRelease(int _absx, int _absy, MouseButton _id);
-
-		/** Inject KeyPress event
-			@return true if event has been processed by GUI
-		*/
-		bool injectKeyPress(KeyCode _key, Char _text = 0);
-		/** Inject KeyReleas event
-			@return true if event has been processed by GUI
-		*/
-		bool injectKeyRelease(KeyCode _key);
-
-		/** Destroy any created widget */
-		void destroyWidget(Widget* _widget);
-
-		/** Destroy vector of widgets */
-		void destroyWidgets(VectorWidgetPtr& _widgets);
-
-		/** Destroy Enumerator of widgets */
-		void destroyWidgets(EnumeratorWidgetPtr& _widgets);
-
-		/** Find widget by name
-			If widget is not found the exception will be thrown, or if the second parameter is false the nullptr pointer will be returned
-		*/
-		Widget* findWidgetT(const std::string& _name, bool _throw = true);
-
-		/** Find widget by name and prefix
-			If widget is not found the exception will be thrown, or if the second parameter is false the nullptr pointer will be returned
-		*/
-		Widget* findWidgetT(const std::string& _name, const std::string& _prefix, bool _throw = true)
-		{
-			return findWidgetT(_prefix + _name, _throw);
-		}
-
-		// mirror WidgetManager
-		/** Find widget by name and cast it to T type.
-			If widget not found or T and found widget have different types cause exception, or if the second parameter is false the nullptr pointer will be returned
-		*/
-		template <typename T>
-		T* findWidget(const std::string& _name, bool _throw = true)
-		{
-			Widget* widget = findWidgetT(_name, _throw);
-			if (nullptr == widget) return nullptr;
-			return widget->castType<T>(_throw);
-		}
-
-		/** Find widget by name and prefix and cast it to T type
-			If widget not found or T and found widget have different types cause exception, or if the second parameter is false the nullptr pointer will be returned
-		*/
-		template <typename T>
-		T* findWidget(const std::string& _name, const std::string& _prefix, bool _throw = true)
-		{
-			return findWidget<T>(_prefix + _name, _throw);
-		}
-
-
-		/** Show or hide mouse pointer */
-		void setVisiblePointer(bool _visible);
-		/** Is mouse pointer visible */
-		bool isVisiblePointer();
-
-
-		// mirror ResourceManager
-		/** Load config with any info (file can have different data such other config files that will be loaded, skins, layers, pointers, etc) */
-		bool load(const std::string& _file);
-
-		void resizeWindow(const IntSize& _size);
-
-		/** Destroy child widget or throw exception if this child widget not found */
-		void destroyChildWidget(Widget* _widget) { _destroyChildWidget(_widget); }
-
-		/** Destroy all child widgets */
-		void destroyAllChildWidget() { _destroyAllChildWidget(); }
-
-		/** Get name of Gui ResourceGroup*/
-		//static const std::string& getResourceGroup();
-
-		/** Get root widgets Enumerator */
-		EnumeratorWidgetPtr getEnumerator() { return EnumeratorWidgetPtr(mWidgetChild); }
-
-	/*internal:*/
-
-		/** Inject frame entered event (called be renderer, do not call it manually).
-			This function is called every frame by renderer.
-		*/
-		void _injectFrameEntered(float _time);
-
-	/*event:*/
-		/** Multidelegate for GUI per frame call.\n
-			signature : void method(float _time)\n
-			@param _time Time elapsed since last frame
-		*/
-		FrameEventDelegate eventFrameStart;
-
-	/*obsolete:*/
-#ifndef MYGUI_DONT_USE_OBSOLETE
-
-		MYGUI_OBSOLETE("use : void Gui::destroyWidgets(VectorWidgetPtr &_widgets)")
-		void destroyWidgetsVector(VectorWidgetPtr& _widgets) { destroyWidgets(_widgets); }
-
-		MYGUI_OBSOLETE("use : void Gui::setVisiblePointer(bool _value)")
-		void hidePointer() { setVisiblePointer(false); }
-		MYGUI_OBSOLETE("use : void Gui::setVisiblePointer(bool _value)")
-		void showPointer() { setVisiblePointer(true); }
-		MYGUI_OBSOLETE("use : bool Gui::isVisiblePointer()")
-		bool isShowPointer() { return isVisiblePointer(); }
-		MYGUI_OBSOLETE("called be renderer, do not call it manually")
-		void injectFrameEntered(float _time) { }
-
-#endif // MYGUI_DONT_USE_OBSOLETE
-
-	private:
-		// создает виджет
-		virtual Widget* baseCreateWidget(WidgetStyle _style, const std::string& _type, const std::string& _skin, const IntCoord& _coord, Align _align, const std::string& _layer, const std::string& _name);
-
-		// удяляет неудачника
-		void _destroyChildWidget(Widget* _widget);
-
-		// удаляет всех детей
-		void _destroyAllChildWidget();
-
-		virtual void _unlinkWidget(Widget* _widget);
-
-		// добавляет в список виджет
-		virtual void _linkChildWidget(Widget* _widget);
-
-		// удаляет из списка
-		virtual void _unlinkChildWidget(Widget* _widget);
-
-
-	private:
-		// вектор всех детей виджетов
-		VectorWidgetPtr mWidgetChild;
-
-		// размеры экрана
-		IntSize mViewSize;
-
-		// синглтоны гуя
-		InputManager * mInputManager;
-		SubWidgetManager * mSubWidgetManager;
-		LayerManager* mLayerManager;
-		SkinManager* mSkinManager;
-		WidgetManager* mWidgetManager;
-		FontManager* mFontManager;
-		ControllerManager* mControllerManager;
-		PointerManager* mPointerManager;
-		ClipboardManager* mClipboardManager;
-		LayoutManager* mLayoutManager;
-		DynLibManager* mDynLibManager;
-		PluginManager* mPluginManager;
-		LanguageManager* mLanguageManager;
-		ResourceManager* mResourceManager;
-		FactoryManager* mFactoryManager;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_GUI_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_Guid.h

@@ -1,137 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		09/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_GUID_H__
-#define __MYGUI_GUID_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-#include <memory.h>
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT Guid
-	{
-	public:
-		Guid() { fast._data1 = fast._data2 = fast._data3 = fast._data4 = 0; }
-		Guid( Guid const& _value ) { *this = _value; }
-		explicit Guid(const std::string& _value) { *this = parse(_value); }
-		explicit Guid(unsigned char(&_id)[16]) { ::memcpy((void*)&vec._data1[0], (void*)&_id[0], 16); }
-
-		bool operator == (Guid const& _comp) const
-		{
-			return _comp.fast._data1 == fast._data1
-				&& _comp.fast._data2 == fast._data2
-				&& _comp.fast._data3 == fast._data3
-				&& _comp.fast._data4 == fast._data4;
-		}
-
-		bool operator != ( Guid const& _comp ) const
-		{
-			return ! (*this == _comp);
-		}
-
-		bool operator < ( Guid const& _comp ) const
-		{
-			if (_comp.fast._data1 < fast._data1) return true;
-			else if (_comp.fast._data1 > fast._data1) return false;
-			if (_comp.fast._data2 < fast._data2) return true;
-			else if (_comp.fast._data2 > fast._data2) return false;
-			if (_comp.fast._data3 < fast._data3) return true;
-			else if (_comp.fast._data3 > fast._data3) return false;
-			if (_comp.fast._data4 < fast._data4) return true;
-			return false;
-		}
-
-		Guid& operator = (Guid const& _rvalue)
-		{
-			fast._data1 = _rvalue.fast._data1;
-			fast._data2 = _rvalue.fast._data2;
-			fast._data3 = _rvalue.fast._data3;
-			fast._data4 = _rvalue.fast._data4;
-			return *this;
-		}
-
-		bool empty() const
-		{
-			return fast._data1 == 0
-				&& fast._data2 == 0
-				&& fast._data3 == 0
-				&& fast._data4 == 0;
-		}
-
-		void clear()
-		{
-			fast._data1 = fast._data2 = fast._data3 = fast._data4 = 0;
-		}
-
-		std::string print() const;
-		static Guid parse(const std::string& _value);
-		static Guid generate();
-
-		friend std::ostream& operator << ( std::ostream& _stream, const Guid&  _value )
-		{
-			_stream << _value.print();
-			return _stream;
-		}
-
-		friend std::istream& operator >> ( std::istream& _stream, Guid&  _value )
-		{
-			std::string value;
-			_stream >> value;
-			if (_stream.fail()) _value.clear();
-			else _value = Guid::parse(value);
-			return _stream;
-		}
-
-	private:
-		// массив для быстрой конвертации
-		static const char convert_hex[64];
-
-		struct _original
-		{
-			uint32 data1;
-			uint16 data2, data3;
-			uint8 data4[8];
-		};
-		struct _fast
-		{
-			uint32 _data1, _data2, _data3, _data4;
-		};
-		struct _vec
-		{
-			unsigned char _data1[16];
-		};
-
-		union
-		{
-			_original original;
-			_fast fast;
-			_vec vec;
-		};
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_GUID_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_HScroll.h

@@ -1,67 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_HSCROLL_H__
-#define __MYGUI_HSCROLL_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_VScroll.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT HScroll :
-		public VScroll
-	{
-		MYGUI_RTTI_DERIVED( HScroll )
-
-	public:
-		HScroll();
-
-		//! @copydoc VScroll::getLineSize()
-		virtual int getLineSize();
-
-		//! @copydoc VScroll::setTrackSize(int _value)
-		virtual void setTrackSize(int _value);
-		//! @copydoc VScroll::getTrackSize()
-		virtual int getTrackSize();
-
-	/*internal:*/
-		virtual void _initialise(WidgetStyle _style, const IntCoord& _coord, Align _align, ResourceSkin* _info, Widget* _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string& _name);
-
-	protected:
-		virtual ~HScroll();
-
-		void baseChangeWidgetSkin(ResourceSkin* _info);
-
-	private:
-		void initialiseWidgetSkin(ResourceSkin* _info);
-		void shutdownWidgetSkin();
-
-		void TrackMove(int _left, int _top);
-		void updateTrack();
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_HSCROLL_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_IBItemInfo.h

@@ -1,111 +0,0 @@
-/*!
-	@file
-	@author		Albert Semenov
-	@date		11/2008
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_ITEM_INFO_H__
-#define __MYGUI_ITEM_INFO_H__
-
-#include "MyGUI_Prerequest.h"
-
-namespace MyGUI
-{
-
-	// структура информации об отображении элемента
-	/** Info about ItemBox item*/
-	struct MYGUI_EXPORT IBDrawItemInfo
-	{
-
-		IBDrawItemInfo() :
-			index(ITEM_NONE),
-			update(false),
-			select(false),
-			active(false),
-			drag(false),
-			drop_accept(false),
-			drop_refuse(false)
-		{
-		}
-
-		IBDrawItemInfo(size_t _index, size_t _select, size_t _active, size_t _accept, size_t _refuse, bool _update, bool _drag) :
-			index(_index),
-			update(_update),
-			select(_index == _select),
-			active(_index == _active),
-			drag(_drag),
-			drop_accept(_index == _accept),
-			drop_refuse(_index == _refuse)
-		{
-		}
-
-		/** Index of element */
-		size_t index;
-		/** State and interdan data changed */
-		bool update;
-		/** Is widget selected */
-		bool select;
-		/** Is widget active */
-		bool active;
-		/** Is widget able to be dragged */
-		bool drag;
-		/** Is widget accepting drop */
-		bool drop_accept;
-		/** Is widget refuseing drop */
-		bool drop_refuse;
-	};
-
-	struct MYGUI_EXPORT IBNotifyItemData
-	{
-		enum NotifyItem
-		{
-			MousePressed,
-			MouseReleased,
-			KeyPressed,
-			KeyReleased
-		};
-
-		IBNotifyItemData(size_t _index, NotifyItem _notify, int _x, int _y, MouseButton _id) :
-			index(_index), notify(_notify), x(_x), y(_y), id(_id), code(KeyCode::None), key(0) { }
-
-		IBNotifyItemData(size_t _index, NotifyItem _notify, KeyCode _code, Char _key) :
-			index(_index), notify(_notify), x(0), y(0), id(MouseButton::None), code(_code), key(_key) { }
-
-		IBNotifyItemData(size_t _index, NotifyItem _notify, KeyCode _code) :
-			index(_index), notify(_notify), x(0), y(0), id(MouseButton::None), code(_code), key(KeyCode::None) { }
-
-		/** Item index */
-		size_t index;
-		/** Notify type */
-		NotifyItem notify;
-		/** If Mouse* notify type - mouse x position, else 0 */
-		int x;
-		/** If Mouse* notify type - mouse y position, else 0 */
-		int y;
-		/** If Mouse* notify type - mouse button id position, else 0 */
-		MouseButton id;
-		/** If Key* notify type - key code, else 0 */
-		KeyCode code;
-		/** If Key* notify type - mouse button id position, else 0 */
-		Char key;
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_ITEM_INFO_H__

extern/mygui_3.0.1/MyGUIEngine/include/MyGUI_ICroppedRectangle.h

@@ -1,213 +0,0 @@
-/*!
-	@file
-	@author		Georgiy Evmenov
-	@date		11/2007
-	@module
-*/
-/*
-	This file is part of MyGUI.
-
-	MyGUI is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Lesser General Public License as published by
-	the Free Software Foundation, either version 3 of the License, or
-	(at your option) any later version.
-
-	MyGUI is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY; without even the implied warranty of
-	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-	GNU Lesser General Public License for more details.
-
-	You should have received a copy of the GNU Lesser General Public License
-	along with MyGUI.  If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef __MYGUI_I_CROPPED_RECTANGLE_H__
-#define __MYGUI_I_CROPPED_RECTANGLE_H__
-
-#include "MyGUI_Prerequest.h"
-#include "MyGUI_Types.h"
-
-namespace MyGUI
-{
-
-	class MYGUI_EXPORT ICroppedRectangle
-	{
-	public:
-		ICroppedRectangle() :
-			mIsMargin(false),
-			mCroppedParent(nullptr),
-			mVisible(true),
-			mAlign(Align::Default)
-		{ }
-
-		virtual ~ICroppedRectangle() { }
-
-		/** Get parent ICroppedRectangle */
-		ICroppedRectangle * getCroppedParent() { return mCroppedParent; }
-
-		/** Set coordinates (position and size) */
-		virtual void setCoord(const IntCoord& _value) { mCoord = _value; }
-		/** Get coordinates (position and size) */
-		const IntCoord& getCoord() const { return mCoord; }
-
-		/** Set position */
-		virtual void setPosition(const IntPoint& _value) { mCoord.left = _value.left; mCoord.top = _value.top; }
-		/** Get position */
-		IntPoint getPosition() const { return mCoord.point(); }
-
-		/** Set size */
-		virtual void setSize(const IntSize& _value) { mCoord.width = _value.width; mCoord.height = _value.height; }
-		/** Get size */
-		IntSize getSize() const { return mCoord.size(); }
-
-		/** Hide or show */
-		virtual void setVisible(bool _value) { mVisible = _value; }
-		/** Return true if visible */
-		bool isVisible() const { return mVisible; }
-
-		/** Get position in screen coordinates */
-		const IntPoint& getAbsolutePosition() const { return mAbsolutePosition; }
-		/** Get rectangle in screen coordinates */
-		IntRect getAbsoluteRect() const { return IntRect(mAbsolutePosition.left, mAbsolutePosition.top, mAbsolutePosition.left+mCoord.width, mAbsolutePosition.top+mCoord.height); }
-		/** Get coordinate in screen coordinates */
-		IntCoord getAbsoluteCoord() const { return IntCoord(mAbsolutePosition.left, mAbsolutePosition.top, mCoord.width, mCoord.height); }
-
-		/** Get X in screen coordinates */
-		int getAbsoluteLeft() const { return mAbsolutePosition.left; }
-		/** Get Y in screen coordinates */
-		int getAbsoluteTop() const { return mAbsolutePosition.top; }
-
-		/** Set align */
-		virtual void setAlign(Align _value) { mAlign = _value; }
-		/** Get align */
-		Align getAlign() const { return mAlign; }
-
-		/** Get left x-coordinate */
-		int getLeft() const { return mCoord.left; }
-		/** Get right x-coordinate */
-		int getRight() const { return mCoord.right(); }
-		/** Get top y-coordinate */
-		int getTop() const { return mCoord.top; }
-		/** Get bottom y-coordinate */
-		int getBottom() const { return mCoord.bottom(); }
-		/** Get width */
-		int getWidth() const { return mCoord.width; }
-		/** Get height */
-		int getHeight() const { return mCoord.height; }
-
-
-	/*internal:*/
-		/** True if rectangle is cropped by parent rectangle */
-		bool _isMargin() const { return mIsMargin; }
-
-		// Get cropped by parent rectangle coordinates
-		int _getViewLeft() const { return mCoord.left + mMargin.left; }
-		int _getViewRight() const { return mCoord.right() - mMargin.right; }
-		int _getViewTop() const { return mCoord.top + mMargin.top; }
-		int _getViewBottom() const { return mCoord.bottom() - mMargin.bottom; }
-		int _getViewWidth() const { return mCoord.width - mMargin.left - mMargin.right; }
-		int _getViewHeight() const { return mCoord.height - mMargin.top - mMargin.bottom; }
-
-		virtual void _updateView() { }
-		virtual void _correctView() { }
-		virtual void _setAlign(const IntSize& _oldsize, bool _update)  { }
-		virtual void _setAlign(const IntCoord& _oldcoord, bool _update) { }
-
-		void _setCroppedParent(ICroppedRectangle* _parent) { mCroppedParent = _parent; }
-
-		const IntRect& _getMargin() const { return mMargin; }
-		int _getMarginLeft() const { return mMargin.left; }
-		int _getMarginRight() const { return mMargin.right; }
-		int _getMarginTop() const { return mMargin.top; }
-		int _getMarginBottom() const { return mMargin.bottom; }
-
-	/*obsolete:*/
-#ifndef MYGUI_DONT_USE_OBSOLETE
-
-		MYGUI_OBSOLETE("use : void ICroppedRectangle::setVisible(bool _visible)")
-		void show() { setVisible(true); }
-		MYGUI_OBSOLETE("use : void ICroppedRectangle::setVisible(bool _visible)")
-		void hide() { setVisible(false); }
-		MYGUI_OBSOLETE("use : bool ICroppedRectangle::isVisible()")
-		bool isShow() { return isVisible(); }
-
-#endif // MYGUI_DONT_USE_OBSOLETE
-
-	protected:
-		bool _checkPoint(int _left, int _top)
-		{
-			return ! ((_getViewLeft() > _left) || (_getViewTop() > _top) || (_getViewRight() < _left) || (_getViewBottom() < _top));
-		}
-
-		bool _checkMargin()
-		{
-			bool margin = false;
-			//вылезли ли налево
-			if (getLeft() < mCroppedParent->mMargin.left)
-			{
-				mMargin.left = mCroppedParent->mMargin.left - getLeft();
-				margin = true;
-			}
-			else
-			{
-				mMargin.left = 0;
-			}
-
-			//вылезли ли направо
-			if (getRight() > mCroppedParent->getWidth() - mCroppedParent->mMargin.right)
-			{
-				mMargin.right = getRight() - (mCroppedParent->getWidth() - mCroppedParent->mMargin.right);
-				margin = true;
-			}
-			else
-			{
-				mMargin.right = 0;
-			}
-
-			//вылезли ли вверх
-			if (getTop() < mCroppedParent->mMargin.top)
-			{
-				mMargin.top = mCroppedParent->mMargin.top - getTop();
-				margin = true;
-			}
-			else
-			{
-				mMargin.top = 0;
-			}
-
-			//вылезли ли вниз
-			if (getBottom() > mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom)
-			{
-				mMargin.bottom = getBottom() - (mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom);
-				margin = true;
-			}
-			else
-			{
-				mMargin.bottom = 0;
-			}
-
-			return margin;
-		}
-
-		bool _checkOutside() // проверка на полный выход за границу
-		{
-			return ( (getRight() < mCroppedParent->mMargin.left ) || // совсем уехали налево
-				(getLeft() > mCroppedParent->getWidth() - mCroppedParent->mMargin.right ) || // совсем уехали направо
-				(getBottom() < mCroppedParent->mMargin.top  ) || // совсем уехали вверх
-				(getTop() > mCroppedParent->getHeight() - mCroppedParent->mMargin.bottom ) );  // совсем уехали вниз
-		}
-
-	protected:
-		bool mIsMargin;
-		IntRect mMargin; // перекрытие
-		IntCoord mCoord; // координаты
-		IntPoint mAbsolutePosition; // обсолютные координаты
-
-		ICroppedRectangle * mCroppedParent;
-		bool mVisible;
-		Align mAlign;
-
-	};
-
-} // namespace MyGUI
-
-#endif // __MYGUI_I_CROPPED_RECTANGLE_H__