Merge remote-tracking branch 'upstream/next' into settings_selwidget

apps/esmtool/labels.cpp

@@ -16,7 +16,7 @@
 #include <iostream>
 #include <boost/format.hpp>
 
-std::string bodyPartLabel(char idx)
+std::string bodyPartLabel(int idx)
 {
     const char *bodyPartLabels[] =  {
         "Head",
@@ -48,13 +48,13 @@ std::string bodyPartLabel(char idx)
         "Tail"
     };
 
-    if ((int)idx >= 0 && (int)(idx) <= 26)
+    if (idx >= 0 && idx <= 26)
-        return bodyPartLabels[(int)(idx)];
+        return bodyPartLabels[idx];
     else
         return "Invalid";
 }
 
-std::string meshPartLabel(char idx)
+std::string meshPartLabel(int idx)
 {
     const char *meshPartLabels[] =  {
         "Head",
@@ -74,13 +74,13 @@ std::string meshPartLabel(char idx)
         "Tail"
     };
 
-    if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MP_Tail)
+    if (idx >= 0 && idx <= ESM::BodyPart::MP_Tail)
-        return meshPartLabels[(int)(idx)];
+        return meshPartLabels[idx];
     else
         return "Invalid";
 }
 
-std::string meshTypeLabel(char idx)
+std::string meshTypeLabel(int idx)
 {
     const char *meshTypeLabels[] =  {
         "Skin",
@@ -88,8 +88,8 @@ std::string meshTypeLabel(char idx)
         "Armor"
     };
 
-    if ((int)(idx) >= 0 && (int)(idx) <= ESM::BodyPart::MT_Armor)
+    if (idx >= 0 && idx <= ESM::BodyPart::MT_Armor)
-        return meshTypeLabels[(int)(idx)];
+        return meshTypeLabels[idx];
     else
         return "Invalid";
 }

apps/esmtool/labels.hpp

@@ -3,9 +3,9 @@
 
 #include <string>
 
-std::string bodyPartLabel(char idx);
+std::string bodyPartLabel(int idx);
-std::string meshPartLabel(char idx);
+std::string meshPartLabel(int idx);
-std::string meshTypeLabel(char idx);
+std::string meshTypeLabel(int idx);
 std::string clothingTypeLabel(int idx);
 std::string armorTypeLabel(int idx);
 std::string dialogTypeLabel(int idx);

apps/opencs/CMakeLists.txt

@@ -59,7 +59,7 @@ opencs_units (view/world
     )
 
 opencs_units_noqt (view/world
-    dialoguesubview util subviews
+    dialoguesubview util subviews enumdelegate vartypedelegate
     )
 
 
@@ -75,7 +75,7 @@ opencs_units_noqt (view/tools
 set (OPENCS_US
     )
 
-set (OPENCS_RES
+set (OPENCS_RES ../../files/opencs/resources.qrc
     )
 
 source_group (opencs FILES ${OPENCS_SRC} ${OPENCS_HDR})

apps/opencs/main.cpp

@@ -5,6 +5,7 @@
 #include <iostream>
 
 #include <QtGui/QApplication>
+#include <QIcon>
 
 class Application : public QApplication
 {
@@ -31,8 +32,11 @@ class Application : public QApplication
 
 int main(int argc, char *argv[])
 {
+    Q_INIT_RESOURCE (resources);
     Application mApplication (argc, argv);
 
+    mApplication.setWindowIcon (QIcon (":./opencs.png"));
+
     CS::Editor editor;
 
     return editor.run();

apps/opencs/model/doc/document.cpp

@@ -18,6 +18,136 @@ void CSMDoc::Document::load (const std::vector<boost::filesystem::path>::const_i
 
     if (lastAsModified)
         getData().loadFile (*end2, false);
+
+    addOptionalGmsts();
+}
+
+void CSMDoc::Document::addOptionalGmsts()
+{
+    static const char *sFloats[] =
+    {
+        "fCombatDistanceWerewolfMod",
+        "fFleeDistance",
+        "fWereWolfAcrobatics",
+        "fWereWolfAgility",
+        "fWereWolfAlchemy",
+        "fWereWolfAlteration",
+        "fWereWolfArmorer",
+        "fWereWolfAthletics",
+        "fWereWolfAxe",
+        "fWereWolfBlock",
+        "fWereWolfBluntWeapon",
+        "fWereWolfConjuration",
+        "fWereWolfDestruction",
+        "fWereWolfEnchant",
+        "fWereWolfEndurance",
+        "fWereWolfFatigue",
+        "fWereWolfHandtoHand",
+        "fWereWolfHealth",
+        "fWereWolfHeavyArmor",
+        "fWereWolfIllusion",
+        "fWereWolfIntellegence",
+        "fWereWolfLightArmor",
+        "fWereWolfLongBlade",
+        "fWereWolfLuck",
+        "fWereWolfMagicka",
+        "fWereWolfMarksman",
+        "fWereWolfMediumArmor",
+        "fWereWolfMerchantile",
+        "fWereWolfMysticism",
+        "fWereWolfPersonality",
+        "fWereWolfRestoration",
+        "fWereWolfRunMult",
+        "fWereWolfSecurity",
+        "fWereWolfShortBlade",
+        "fWereWolfSilverWeaponDamageMult",
+        "fWereWolfSneak",
+        "fWereWolfSpear",
+        "fWereWolfSpeechcraft",
+        "fWereWolfSpeed",
+        "fWereWolfStrength",
+        "fWereWolfUnarmored",
+        "fWereWolfWillPower",
+        0
+    };
+
+    static const char *sIntegers[] =
+    {
+        "iWereWolfBounty",
+        "iWereWolfFightMod",
+        "iWereWolfFleeMod",
+        "iWereWolfLevelToAttack",
+        0
+    };
+
+    static const char *sStrings[] =
+    {
+        "sCompanionShare",
+        "sCompanionWarningButtonOne",
+        "sCompanionWarningButtonTwo",
+        "sCompanionWarningMessage",
+        "sDeleteNote",
+        "sEditNote",
+        "sEffectSummonCreature01",
+        "sEffectSummonCreature02",
+        "sEffectSummonCreature03",
+        "sEffectSummonCreature04",
+        "sEffectSummonCreature05",
+        "sEffectSummonFabricant",
+        "sLevitateDisabled",
+        "sMagicCreature01ID",
+        "sMagicCreature02ID",
+        "sMagicCreature03ID",
+        "sMagicCreature04ID",
+        "sMagicCreature05ID",
+        "sMagicFabricantID",
+        "sMaxSale",
+        "sProfitValue",
+        "sTeleportDisabled",
+        "sWerewolfAlarmMessage",
+        "sWerewolfPopup",
+        "sWerewolfRefusal",
+        "sWerewolfRestMessage",
+        0
+    };
+
+    for (int i=0; sFloats[i]; ++i)
+    {
+        ESM::GameSetting gmst;
+        gmst.mId = sFloats[i];
+        gmst.mF = 0;
+        gmst.mType = ESM::VT_Float;
+        addOptionalGmst (gmst);
+    }
+
+    for (int i=0; sIntegers[i]; ++i)
+    {
+        ESM::GameSetting gmst;
+        gmst.mId = sIntegers[i];
+        gmst.mI = 0;
+        gmst.mType = ESM::VT_Long;
+        addOptionalGmst (gmst);
+    }
+
+    for (int i=0; sStrings[i]; ++i)
+    {
+        ESM::GameSetting gmst;
+        gmst.mId = sStrings[i];
+        gmst.mStr = "<no text>";
+        gmst.mType = ESM::VT_String;
+        addOptionalGmst (gmst);
+    }
+}
+
+void CSMDoc::Document::addOptionalGmst (const ESM::GameSetting& gmst)
+{
+    if (getData().getGmsts().searchId (gmst.mId)==-1)
+    {
+        CSMWorld::Record<ESM::GameSetting> record;
+        record.mBase = gmst;
+        record.mState = CSMWorld::RecordBase::State_BaseOnly;
+        getData().getGmsts().appendRecord (record);
+    }
 }
 
 void CSMDoc::Document::createBase()

apps/opencs/model/doc/document.hpp

@@ -17,6 +17,11 @@
 
 class QAbstractItemModel;
 
+namespace ESM
+{
+    struct GameSetting;
+}
+
 namespace CSMDoc
 {
     class Document : public QObject
@@ -46,6 +51,10 @@ namespace CSMDoc
 
             void createBase();
 
+            void addOptionalGmsts();
+
+            void addOptionalGmst (const ESM::GameSetting& gmst);
+
         public:
 
             Document (const std::vector<boost::filesystem::path>& files, bool new_);

apps/opencs/model/world/columnbase.hpp

@@ -29,7 +29,8 @@ namespace CSMWorld
             Display_String,
             Display_Integer,
             Display_Float,
-            Display_Var
+            Display_Var,
+            Display_VarType
         };
 
         std::string mTitle;

apps/opencs/model/world/columns.hpp

@@ -79,7 +79,7 @@ namespace CSMWorld
         int mType;
 
         FixedRecordTypeColumn (int type)
-        : Column<ESXRecordT> ("Type", ColumnBase::Display_Integer, 0), mType (type) {}
+        : Column<ESXRecordT> ("Record Type", ColumnBase::Display_Integer, 0), mType (type) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {
@@ -92,10 +92,11 @@ namespace CSMWorld
         }
     };
 
+    /// \attention A var type column must be immediately followed by a suitable value column.
     template<typename ESXRecordT>
     struct VarTypeColumn : public Column<ESXRecordT>
     {
-        VarTypeColumn() : Column<ESXRecordT> ("Type", ColumnBase::Display_Integer) {}
+        VarTypeColumn() : Column<ESXRecordT> ("Type", ColumnBase::Display_VarType) {}
 
         virtual QVariant get (const Record<ESXRecordT>& record) const
         {

apps/opencs/model/world/data.cpp

@@ -54,6 +54,16 @@ CSMWorld::IdCollection<ESM::Global>& CSMWorld::Data::getGlobals()
     return mGlobals;
 }
 
+const CSMWorld::IdCollection<ESM::GameSetting>& CSMWorld::Data::getGmsts() const
+{
+    return mGmsts;
+}
+
+CSMWorld::IdCollection<ESM::GameSetting>& CSMWorld::Data::getGmsts()
+{
+    return mGmsts;
+}
+
 QAbstractTableModel *CSMWorld::Data::getTableModel (const UniversalId& id)
 {
     std::map<UniversalId::Type, QAbstractTableModel *>::iterator iter = mModelIndex.find (id.getType());
@@ -72,7 +82,11 @@ void CSMWorld::Data::merge()
 void CSMWorld::Data::loadFile (const boost::filesystem::path& path, bool base)
 {
     ESM::ESMReader reader;
-    /// \todo set encoder
+
+    /// \todo set encoding properly, once config implementation has been fixed.
+    ToUTF8::Utf8Encoder encoder (ToUTF8::calculateEncoding ("win1252"));
+    reader.setEncoder (&encoder);
+
     reader.open (path.string());
 
     // Note: We do not need to send update signals here, because at this point the model is not connected

apps/opencs/model/world/data.hpp

@@ -40,6 +40,10 @@ namespace CSMWorld
 
             IdCollection<ESM::Global>& getGlobals();
 
+            const IdCollection<ESM::GameSetting>& getGmsts() const;
+
+            IdCollection<ESM::GameSetting>& getGmsts();
+
             QAbstractTableModel *getTableModel (const UniversalId& id);
             ///< If no table model is available for \a id, an exception is thrown.
             ///

apps/opencs/view/doc/opendialog.cpp

@@ -11,7 +11,7 @@ OpenDialog::OpenDialog(QWidget * parent) : QDialog(parent)
     mFileSelector = new DataFilesList(mCfgMgr, this);
     layout->addWidget(mFileSelector);
 
-    //FIXME - same as DataFilesPage::setupDataFiles
+    /// \todo move config to Editor class and add command line options.
     // We use the Configuration Manager to retrieve the configuration values
     boost::program_options::variables_map variables;
     boost::program_options::options_description desc;

apps/opencs/view/doc/viewmanager.cpp

@@ -6,6 +6,10 @@
 #include "../../model/doc/documentmanager.hpp"
 #include "../../model/doc/document.hpp"
 
+#include "../world/util.hpp"
+#include "../world/enumdelegate.hpp"
+#include "../world/vartypedelegate.hpp"
+
 #include "view.hpp"
 
 void CSVDoc::ViewManager::updateIndices()
@@ -29,11 +33,16 @@ void CSVDoc::ViewManager::updateIndices()
 CSVDoc::ViewManager::ViewManager (CSMDoc::DocumentManager& documentManager)
 : mDocumentManager (documentManager)
 {
+    mDelegateFactories = new CSVWorld::CommandDelegateFactoryCollection;
 
+    mDelegateFactories->add (CSMWorld::ColumnBase::Display_VarType,
+        new CSVWorld::VarTypeDelegateFactory (ESM::VT_None, ESM::VT_String, ESM::VT_Int, ESM::VT_Float));
 }
 
 CSVDoc::ViewManager::~ViewManager()
 {
+    delete mDelegateFactories;
+
     for (std::vector<View *>::iterator iter (mViews.begin()); iter!=mViews.end(); ++iter)
         delete *iter;
 }

apps/opencs/view/doc/viewmanager.hpp

@@ -11,6 +11,11 @@ namespace CSMDoc
     class DocumentManager;
 }
 
+namespace CSVWorld
+{
+    class CommandDelegateFactoryCollection;
+}
+
 namespace CSVDoc
 {
     class View;
@@ -21,6 +26,7 @@ namespace CSVDoc
 
             CSMDoc::DocumentManager& mDocumentManager;
             std::vector<View *> mViews;
+            CSVWorld::CommandDelegateFactoryCollection *mDelegateFactories;
 
             // not implemented
             ViewManager (const ViewManager&);

apps/opencs/view/world/enumdelegate.cpp

@@ -0,0 +1,101 @@
+
+#include "enumdelegate.hpp"
+
+#include <stdexcept>
+
+#include <QComboBox>
+#include <QApplication>
+#include <QUndoStack>
+
+#include "../../model/world/commands.hpp"
+
+void CSVWorld::EnumDelegate::setModelDataImp (QWidget *editor, QAbstractItemModel *model,
+    const QModelIndex& index) const
+{
+    if (QComboBox *comboBox = dynamic_cast<QComboBox *> (editor))
+    {
+        QString value = comboBox->currentText();
+
+        for (std::vector<std::pair<int, QString> >::const_iterator iter (mValues.begin());
+            iter!=mValues.end(); ++iter)
+            if (iter->second==value)
+            {
+                addCommands (model, index, iter->first);
+                break;
+            }
+    }
+}
+
+void CSVWorld::EnumDelegate::addCommands (QAbstractItemModel *model,
+    const QModelIndex& index, int type) const
+{
+    getUndoStack().push (new CSMWorld::ModifyCommand (*model, index, type));
+}
+
+
+CSVWorld::EnumDelegate::EnumDelegate (const std::vector<std::pair<int, QString> >& values,
+    QUndoStack& undoStack, QObject *parent)
+: CommandDelegate (undoStack, parent), mValues (values)
+{
+
+}
+
+QWidget *CSVWorld::EnumDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem& option,
+    const QModelIndex& index) const
+{
+    QComboBox *comboBox = new QComboBox (parent);
+
+    for (std::vector<std::pair<int, QString> >::const_iterator iter (mValues.begin());
+         iter!=mValues.end(); ++iter)
+         comboBox->addItem (iter->second);
+
+    return comboBox;
+}
+
+void CSVWorld::EnumDelegate::setEditorData (QWidget *editor, const QModelIndex& index) const
+{
+    if (QComboBox *comboBox = dynamic_cast<QComboBox *> (editor))
+    {
+        int value = index.data (Qt::EditRole).toInt();
+
+        std::size_t size = mValues.size();
+
+        for (std::size_t i=0; i<size; ++i)
+            if (mValues[i].first==value)
+            {
+                comboBox->setCurrentIndex (i);
+                break;
+            }
+    }
+}
+
+void CSVWorld::EnumDelegate::paint (QPainter *painter, const QStyleOptionViewItem& option,
+    const QModelIndex& index) const
+{
+    QStyleOptionViewItemV4 option2 (option);
+
+    int value = index.data().toInt();
+
+    for (std::vector<std::pair<int, QString> >::const_iterator iter (mValues.begin());
+        iter!=mValues.end(); ++iter)
+        if (iter->first==value)
+        {
+            option2.text = iter->second;
+
+            QApplication::style()->drawControl (QStyle::CE_ItemViewItem, &option2, painter);
+
+            break;
+        }
+}
+
+
+CSVWorld::CommandDelegate *CSVWorld::EnumDelegateFactory::makeDelegate (QUndoStack& undoStack,
+    QObject *parent) const
+{
+    return new EnumDelegate (mValues, undoStack, parent);
+}
+
+void CSVWorld::EnumDelegateFactory::add (int value, const QString& name)
+{
+    mValues.push_back (std::make_pair (value, name));
+}

apps/opencs/view/world/enumdelegate.hpp

@@ -0,0 +1,57 @@
+#ifndef CSV_WORLD_ENUMDELEGATE_H
+#define CSV_WORLD_ENUMDELEGATE_H
+
+#include <vector>
+
+#include <QString>
+
+#include <components/esm/defs.hpp>
+
+#include "util.hpp"
+
+namespace CSVWorld
+{
+    /// \brief Integer value that represents an enum and is interacted with via a combobox
+    class EnumDelegate : public CommandDelegate
+    {
+            std::vector<std::pair<int, QString> > mValues;
+
+        private:
+
+            virtual void setModelDataImp (QWidget *editor, QAbstractItemModel *model,
+                const QModelIndex& index) const;
+
+            virtual void addCommands (QAbstractItemModel *model,
+                const QModelIndex& index, int type) const;
+
+        public:
+
+            EnumDelegate (const std::vector<std::pair<int, QString> >& values,
+                QUndoStack& undoStack, QObject *parent);
+
+            virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem& option,
+                const QModelIndex& index) const;
+
+            virtual void setEditorData (QWidget *editor, const QModelIndex& index) const;
+
+            virtual void paint (QPainter *painter, const QStyleOptionViewItem& option,
+                const QModelIndex& index) const;
+
+    };
+
+    class EnumDelegateFactory : public CommandDelegateFactory
+    {
+            std::vector<std::pair<int, QString> > mValues;
+
+        public:
+
+            virtual CommandDelegate *makeDelegate (QUndoStack& undoStack, QObject *parent) const;
+            ///< The ownership of the returned CommandDelegate is transferred to the caller.
+
+            void add (int value, const QString& name);
+    };
+
+
+}
+
+#endif

apps/opencs/view/world/table.cpp

@@ -102,7 +102,12 @@ CSVWorld::Table::Table (const CSMWorld::UniversalId& id, CSMWorld::Data& data, Q
 
         if (flags & CSMWorld::ColumnBase::Flag_Table)
         {
-            CommandDelegate *delegate = new CommandDelegate (undoStack, this);
+            CSMWorld::ColumnBase::Display display = static_cast<CSMWorld::ColumnBase::Display> (
+                mModel->headerData (i, Qt::Horizontal, CSMWorld::ColumnBase::Role_Display).toInt());
+
+            CommandDelegate *delegate = CommandDelegateFactoryCollection::get().makeDelegate (display,
+                undoStack, this);
+
             mDelegates.push_back (delegate);
             setItemDelegateForColumn (i, delegate);
         }

apps/opencs/view/world/util.cpp

@@ -1,6 +1,8 @@
 
 #include "util.hpp"
 
+#include <stdexcept>
+
 #include <QUndoStack>
 
 #include "../../model/world/commands.hpp"
@@ -35,6 +37,70 @@ QVariant CSVWorld::NastyTableModelHack::getData() const
     return mData;
 }
 
+
+CSVWorld::CommandDelegateFactory::~CommandDelegateFactory() {}
+
+
+CSVWorld::CommandDelegateFactoryCollection *CSVWorld::CommandDelegateFactoryCollection::sThis = 0;
+
+CSVWorld::CommandDelegateFactoryCollection::CommandDelegateFactoryCollection()
+{
+    if (sThis)
+        throw std::logic_error ("multiple instances of CSVWorld::CommandDelegateFactoryCollection");
+
+    sThis = this;
+}
+
+CSVWorld::CommandDelegateFactoryCollection::~CommandDelegateFactoryCollection()
+{
+    sThis = 0;
+
+    for (std::map<CSMWorld::ColumnBase::Display, CommandDelegateFactory *>::iterator iter (
+        mFactories.begin());
+        iter!=mFactories.end(); ++iter)
+         delete iter->second;
+}
+
+void CSVWorld::CommandDelegateFactoryCollection::add (CSMWorld::ColumnBase::Display display,
+    CommandDelegateFactory *factory)
+{
+    mFactories.insert (std::make_pair (display, factory));
+}
+
+CSVWorld::CommandDelegate *CSVWorld::CommandDelegateFactoryCollection::makeDelegate (
+    CSMWorld::ColumnBase::Display display, QUndoStack& undoStack, QObject *parent) const
+{
+    std::map<CSMWorld::ColumnBase::Display, CommandDelegateFactory *>::const_iterator iter =
+        mFactories.find (display);
+
+    if (iter!=mFactories.end())
+        return iter->second->makeDelegate (undoStack, parent);
+
+    return new CommandDelegate (undoStack, parent);
+}
+
+const CSVWorld::CommandDelegateFactoryCollection& CSVWorld::CommandDelegateFactoryCollection::get()
+{
+    if (!sThis)
+        throw std::logic_error ("no instance of CSVWorld::CommandDelegateFactoryCollection");
+
+    return *sThis;
+}
+
+
+QUndoStack& CSVWorld::CommandDelegate::getUndoStack() const
+{
+    return mUndoStack;
+}
+
+void CSVWorld::CommandDelegate::setModelDataImp (QWidget *editor, QAbstractItemModel *model,
+    const QModelIndex& index) const
+{
+    NastyTableModelHack hack (*model);
+    QStyledItemDelegate::setModelData (editor, &hack, index);
+    mUndoStack.push (new CSMWorld::ModifyCommand (*model, index, hack.getData()));
+}
+
 CSVWorld::CommandDelegate::CommandDelegate (QUndoStack& undoStack, QObject *parent)
 : QStyledItemDelegate (parent), mUndoStack (undoStack), mEditLock (false)
 {}
@@ -44,10 +110,9 @@ void CSVWorld::CommandDelegate::setModelData (QWidget *editor, QAbstractItemMode
 {
     if (!mEditLock)
     {
-        NastyTableModelHack hack (*model);
+        setModelDataImp (editor, model, index);
-        QStyledItemDelegate::setModelData (editor, &hack, index);
-        mUndoStack.push (new CSMWorld::ModifyCommand (*model, index, hack.getData()));
     }
+
     ///< \todo provide some kind of feedback to the user, indicating that editing is currently not possible.
 }
 
@@ -55,3 +120,8 @@ void  CSVWorld::CommandDelegate::setEditLock (bool locked)
 {
     mEditLock = locked;
 }
+
+bool CSVWorld::CommandDelegate::isEditLocked() const
+{
+    return mEditLock;
+}

apps/opencs/view/world/util.hpp

@@ -1,9 +1,13 @@
 #ifndef CSV_WORLD_UTIL_H
 #define CSV_WORLD_UTIL_H
 
+#include <map>
+
 #include <QAbstractTableModel>
 #include <QStyledItemDelegate>
 
+#include "../../model/world/columnbase.hpp"
+
 class QUndoStack;
 
 namespace CSVWorld
@@ -31,19 +35,73 @@ namespace CSVWorld
             QVariant getData() const;
     };
 
+    class CommandDelegate;
+
+    class CommandDelegateFactory
+    {
+        public:
+
+            virtual ~CommandDelegateFactory();
+
+            virtual CommandDelegate *makeDelegate (QUndoStack& undoStack, QObject *parent) const = 0;
+            ///< The ownership of the returned CommandDelegate is transferred to the caller.
+    };
+
+    class CommandDelegateFactoryCollection
+    {
+            static CommandDelegateFactoryCollection *sThis;
+            std::map<CSMWorld::ColumnBase::Display, CommandDelegateFactory *> mFactories;
+
+        private:
+
+            // not implemented
+            CommandDelegateFactoryCollection (const CommandDelegateFactoryCollection&);
+            CommandDelegateFactoryCollection& operator= (const CommandDelegateFactoryCollection&);
+
+        public:
+
+            CommandDelegateFactoryCollection();
+
+            ~CommandDelegateFactoryCollection();
+
+            void add (CSMWorld::ColumnBase::Display display, CommandDelegateFactory *factory);
+            ///< The ownership of \æ factory is transferred to *this.
+            ///
+            /// This function must not be called more than once per value of \æ display.
+
+            CommandDelegate *makeDelegate (CSMWorld::ColumnBase::Display display, QUndoStack& undoStack,
+                QObject *parent) const;
+            ///< The ownership of the returned CommandDelegate is transferred to the caller.
+            ///
+            /// If no factory is registered for \a display, a CommandDelegate will be returned.
+
+            static const CommandDelegateFactoryCollection& get();
+
+    };
+
     ///< \brief Use commands instead of manipulating the model directly
     class CommandDelegate : public QStyledItemDelegate
     {
             QUndoStack& mUndoStack;
             bool mEditLock;
 
+        protected:
+
+            QUndoStack& getUndoStack() const;
+
+            virtual void setModelDataImp (QWidget *editor, QAbstractItemModel *model,
+                const QModelIndex& index) const;
+
         public:
 
             CommandDelegate (QUndoStack& undoStack, QObject *parent);
 
-            void setModelData (QWidget *editor, QAbstractItemModel *model, const QModelIndex& index) const;
+            virtual void setModelData (QWidget *editor, QAbstractItemModel *model,
+                const QModelIndex& index) const;
 
             void setEditLock (bool locked);
+
+            bool isEditLocked() const;
     };
 }
 

apps/opencs/view/world/vartypedelegate.cpp

@@ -0,0 +1,103 @@
+
+#include "vartypedelegate.hpp"
+
+#include <QUndoStack>
+
+#include "../../model/world/commands.hpp"
+
+void CSVWorld::VarTypeDelegate::addCommands (QAbstractItemModel *model, const QModelIndex& index, int type)
+    const
+{
+    QModelIndex next = model->index (index.row(), index.column()+1);
+
+    QVariant old = model->data (next);
+
+    QVariant value;
+
+    switch (type)
+    {
+        case ESM::VT_Short:
+        case ESM::VT_Int:
+        case ESM::VT_Long:
+
+            value = old.toInt();
+            break;
+
+        case ESM::VT_Float:
+
+            value = old.toFloat();
+            break;
+
+        case ESM::VT_String:
+
+            value = old.toString();
+            break;
+
+        default: break; // ignore the rest
+    }
+
+    getUndoStack().beginMacro (
+        "Modify " + model->headerData (index.column(), Qt::Horizontal, Qt::DisplayRole).toString());
+
+    getUndoStack().push (new CSMWorld::ModifyCommand (*model, index, type));
+    getUndoStack().push (new CSMWorld::ModifyCommand (*model, next, value));
+
+    getUndoStack().endMacro();
+}
+
+CSVWorld::VarTypeDelegate::VarTypeDelegate (const std::vector<std::pair<int, QString> >& values,
+    QUndoStack& undoStack, QObject *parent)
+: EnumDelegate (values, undoStack, parent)
+{}
+
+
+CSVWorld::VarTypeDelegateFactory::VarTypeDelegateFactory (ESM::VarType type0,
+    ESM::VarType type1, ESM::VarType type2, ESM::VarType type3)
+{
+    if (type0!=ESM::VT_Unknown)
+        add (type0);
+
+    if (type1!=ESM::VT_Unknown)
+        add (type1);
+
+    if (type2!=ESM::VT_Unknown)
+        add (type2);
+
+    if (type3!=ESM::VT_Unknown)
+        add (type3);
+}
+
+CSVWorld::CommandDelegate *CSVWorld::VarTypeDelegateFactory::makeDelegate (QUndoStack& undoStack,
+    QObject *parent) const
+{
+    return new VarTypeDelegate (mValues, undoStack, parent);
+}
+
+void CSVWorld::VarTypeDelegateFactory::add (ESM::VarType type)
+{
+    struct Name
+    {
+        ESM::VarType mType;
+        const char *mName;
+    };
+
+    static const Name sNames[] =
+    {
+        { ESM::VT_None, "empty" },
+        { ESM::VT_Short, "short" },
+        { ESM::VT_Int, "long" },
+        { ESM::VT_Long, "long" },
+        { ESM::VT_Float, "float" },
+        { ESM::VT_String, "string" },
+        { ESM::VT_Unknown, 0 } // end marker
+    };
+
+    for (int i=0; sNames[i].mName; ++i)
+        if (sNames[i].mType==type)
+        {
+            mValues.push_back (std::make_pair (type, sNames[i].mName));
+            return;
+        }
+
+    throw std::logic_error ("Unsupported variable type");
+}

apps/opencs/view/world/vartypedelegate.hpp

@@ -0,0 +1,38 @@
+#ifndef CSV_WORLD_VARTYPEDELEGATE_H
+#define CSV_WORLD_VARTYPEDELEGATE_H
+
+#include "enumdelegate.hpp"
+
+namespace CSVWorld
+{
+    class VarTypeDelegate : public EnumDelegate
+    {
+        private:
+
+            virtual void addCommands (QAbstractItemModel *model,
+                const QModelIndex& index, int type) const;
+
+        public:
+
+            VarTypeDelegate (const std::vector<std::pair<int, QString> >& values,
+                QUndoStack& undoStack, QObject *parent);
+    };
+
+    class VarTypeDelegateFactory : public CommandDelegateFactory
+    {
+            std::vector<std::pair<int, QString> > mValues;
+
+        public:
+
+            VarTypeDelegateFactory (ESM::VarType type0 = ESM::VT_Unknown,
+                ESM::VarType type1 = ESM::VT_Unknown, ESM::VarType type2 = ESM::VT_Unknown,
+                ESM::VarType type3 = ESM::VT_Unknown);
+
+            virtual CommandDelegate *makeDelegate (QUndoStack& undoStack, QObject *parent) const;
+            ///< The ownership of the returned CommandDelegate is transferred to the caller.
+
+            void add (ESM::VarType type);
+    };
+}
+
+#endif

apps/openmw/mwclass/apparatus.cpp

@@ -12,6 +12,7 @@
 #include "../mwworld/actionalchemy.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
@@ -61,6 +62,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Apparatus::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
     	boost::shared_ptr<MWWorld::Action> action(
     	            new MWWorld::ActionTake (ptr));
 

apps/openmw/mwclass/armor.cpp

@@ -15,6 +15,7 @@
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
@@ -64,6 +65,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Armor::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/clothing.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -62,6 +63,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Clothing::activate (const MWWorld::Ptr& ptr,
     		const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
     	boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
     	action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/container.cpp

@@ -9,6 +9,7 @@
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/failedaction.hpp"
+#include "../mwworld/nullaction.hpp"
 #include "../mwworld/containerstore.hpp"
 #include "../mwworld/customdata.hpp"
 #include "../mwworld/cellstore.hpp"
@@ -85,6 +86,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Container::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         const std::string lockedSound = "LockedChest";
         const std::string trapActivationSound = "Disarm Trap Fail";
 

apps/openmw/mwclass/ingredient.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/physicssystem.hpp"
 #include "../mwworld/actioneat.hpp"
 #include "../mwworld/player.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwmechanics/npcstats.hpp"
 
@@ -72,6 +73,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Ingredient::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/light.cpp

@@ -88,6 +88,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Light::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         MWWorld::LiveCellRef<ESM::Light> *ref =
             ptr.get<ESM::Light>();
 

apps/openmw/mwclass/lockpick.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -62,6 +63,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Lockpick::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/misc.cpp

@@ -14,6 +14,7 @@
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
 #include "../mwworld/manualref.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -65,6 +66,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Miscellaneous::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));
@@ -210,6 +214,7 @@ namespace MWClass
             MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
                 newRef.getPtr().get<ESM::Miscellaneous>();
             newPtr = MWWorld::Ptr(&cell.mMiscItems.insert(*ref), &cell);
+            newPtr.getRefData ().setCount(goldAmount);
         } else {
             MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
                 ptr.get<ESM::Miscellaneous>();

apps/openmw/mwclass/potion.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
 #include "../mwworld/player.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -62,6 +63,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Potion::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
     	boost::shared_ptr<MWWorld::Action> action(
     	            new MWWorld::ActionTake (ptr));
 

apps/openmw/mwclass/probe.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -61,6 +62,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Probe::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/repair.cpp

@@ -11,6 +11,7 @@
 #include "../mwworld/actiontake.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -60,6 +61,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Repair::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwclass/weapon.cpp

@@ -13,6 +13,7 @@
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/cellstore.hpp"
 #include "../mwworld/physicssystem.hpp"
+#include "../mwworld/nullaction.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -62,6 +63,9 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Weapon::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
+        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
+            return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionTake (ptr));
 
         action->setSound(getUpSoundId(ptr));

apps/openmw/mwgui/birth.cpp

@@ -48,7 +48,6 @@ BirthDialog::BirthDialog(MWBase::WindowManager& parWindowManager)
     getWidget(okButton, "OKButton");
     okButton->setCaption(mWindowManager.getGameSettingString("sOK", ""));
     okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BirthDialog::onOkClicked);
-    okButton->setEnabled(false);
 
     updateBirths();
     updateSpells();
@@ -85,7 +84,6 @@ void BirthDialog::setBirthId(const std::string &birthId)
             mBirthList->setIndexSelected(i);
             MyGUI::ButtonPtr okButton;
             getWidget(okButton, "OKButton");
-            okButton->setEnabled(true);
             break;
         }
     }
@@ -114,7 +112,6 @@ void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->setEnabled(true);
 
     const std::string *birthId = mBirthList->getItemDataAt<std::string>(_index);
     if (boost::iequals(mCurrentBirthId, *birthId))
@@ -133,8 +130,6 @@ void BirthDialog::updateBirths()
     const MWWorld::Store<ESM::BirthSign> &signs =
         MWBase::Environment::get().getWorld()->getStore().get<ESM::BirthSign>();
 
-    int index = 0;
-
     // sort by name
     std::vector < std::pair<std::string, const ESM::BirthSign*> > birthSigns;
 
@@ -145,12 +140,20 @@ void BirthDialog::updateBirths()
     }
     std::sort(birthSigns.begin(), birthSigns.end(), sortBirthSigns);
 
-    for (std::vector < std::pair<std::string, const ESM::BirthSign*> >::const_iterator it2 = birthSigns.begin(); it2 != birthSigns.end(); ++it2)
+    int index = 0;
+    for (std::vector<std::pair<std::string, const ESM::BirthSign*> >::const_iterator it2 = birthSigns.begin();
+         it2 != birthSigns.end(); ++it2, ++index)
     {
         mBirthList->addItem(it2->second->mName, it2->first);
-        if (boost::iequals(it2->first, mCurrentBirthId))
+        if (mCurrentBirthId.empty())
+        {
             mBirthList->setIndexSelected(index);
-        ++index;
+            mCurrentBirthId = it2->first;
+        }
+        else if (boost::iequals(it2->first, mCurrentBirthId))
+        {
+            mBirthList->setIndexSelected(index);
+        }
     }
 }
 

apps/openmw/mwgui/bookwindow.cpp

@@ -14,8 +14,10 @@
 
 using namespace MWGui;
 
-BookWindow::BookWindow (MWBase::WindowManager& parWindowManager) :
+BookWindow::BookWindow (MWBase::WindowManager& parWindowManager)
-    WindowBase("openmw_book.layout", parWindowManager)
+    : WindowBase("openmw_book.layout", parWindowManager)
+    , mTakeButtonShow(true)
+    , mTakeButtonAllowed(true)
 {
     getWidget(mCloseButton, "CloseButton");
     mCloseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BookWindow::onCloseButtonClicked);
@@ -85,7 +87,14 @@ void BookWindow::open (MWWorld::Ptr book)
 
 void BookWindow::setTakeButtonShow(bool show)
 {
-    mTakeButton->setVisible(show);
+    mTakeButtonShow = show;
+    mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
+}
+
+void BookWindow::setInventoryAllowed(bool allowed)
+{
+    mTakeButtonAllowed = allowed;
+    mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
 }
 
 void BookWindow::onCloseButtonClicked (MyGUI::Widget* sender)

apps/openmw/mwgui/bookwindow.hpp

@@ -17,6 +17,8 @@ namespace MWGui
             void open(MWWorld::Ptr book);
             void setTakeButtonShow(bool show);
 
+            void setInventoryAllowed(bool allowed);
+
         protected:
             void onNextPageButtonClicked (MyGUI::Widget* sender);
             void onPrevPageButtonClicked (MyGUI::Widget* sender);
@@ -40,6 +42,9 @@ namespace MWGui
             std::vector<MyGUI::Widget*> mPages;
 
             MWWorld::Ptr mBook;
+
+            bool mTakeButtonShow;
+            bool mTakeButtonAllowed;
     };
 
 }

apps/openmw/mwgui/class.cpp

@@ -104,7 +104,6 @@ PickClassDialog::PickClassDialog(MWBase::WindowManager& parWindowManager)
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
     okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &PickClassDialog::onOkClicked);
-    okButton->setEnabled(false);
 
     updateClasses();
     updateStats();
@@ -140,7 +139,6 @@ void PickClassDialog::setClassId(const std::string &classId)
             mClassList->setIndexSelected(i);
             MyGUI::ButtonPtr okButton;
             getWidget(okButton, "OKButton");
-            okButton->setEnabled(true);
             break;
         }
     }
@@ -169,7 +167,6 @@ void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->setEnabled(true);
 
     const std::string *classId = mClassList->getItemDataAt<std::string>(_index);
     if (boost::iequals(mCurrentClassId, *classId))
@@ -197,8 +194,15 @@ void PickClassDialog::updateClasses()
 
         const std::string &id = it->mId;
         mClassList->addItem(it->mName, id);
-        if (boost::iequals(id, mCurrentClassId))
+        if (mCurrentClassId.empty())
+        {
+            mCurrentClassId = id;
             mClassList->setIndexSelected(index);
+        }
+        else if (boost::iequals(id, mCurrentClassId))
+        {
+            mClassList->setIndexSelected(index);
+        }
         ++index;
     }
 }

apps/openmw/mwgui/race.cpp

@@ -81,7 +81,6 @@ RaceDialog::RaceDialog(MWBase::WindowManager& parWindowManager)
     getWidget(okButton, "OKButton");
     okButton->setCaption(mWindowManager.getGameSettingString("sOK", ""));
     okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onOkClicked);
-    okButton->setEnabled(false);
 
     updateRaces();
     updateSkills();
@@ -135,7 +134,6 @@ void RaceDialog::setRaceId(const std::string &raceId)
             mRaceList->setIndexSelected(i);
             MyGUI::ButtonPtr okButton;
             getWidget(okButton, "OKButton");
-            okButton->setEnabled(true);
             break;
         }
     }
@@ -258,7 +256,6 @@ void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
 
     MyGUI::ButtonPtr okButton;
     getWidget(okButton, "OKButton");
-    okButton->setEnabled(true);
     const std::string *raceId = mRaceList->getItemDataAt<std::string>(_index);
     if (boost::iequals(mCurrentRaceId, *raceId))
         return;

apps/openmw/mwgui/scrollwindow.cpp

@@ -12,8 +12,10 @@
 
 using namespace MWGui;
 
-ScrollWindow::ScrollWindow (MWBase::WindowManager& parWindowManager) :
+ScrollWindow::ScrollWindow (MWBase::WindowManager& parWindowManager)
-    WindowBase("openmw_scroll.layout", parWindowManager)
+    : WindowBase("openmw_scroll.layout", parWindowManager)
+    , mTakeButtonShow(true)
+    , mTakeButtonAllowed(true)
 {
     getWidget(mTextView, "TextView");
 
@@ -50,7 +52,14 @@ void ScrollWindow::open (MWWorld::Ptr scroll)
 
 void ScrollWindow::setTakeButtonShow(bool show)
 {
-    mTakeButton->setVisible(show);
+    mTakeButtonShow = show;
+    mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
+}
+
+void ScrollWindow::setInventoryAllowed(bool allowed)
+{
+    mTakeButtonAllowed = allowed;
+    mTakeButton->setVisible(mTakeButtonShow && mTakeButtonAllowed);
 }
 
 void ScrollWindow::onCloseButtonClicked (MyGUI::Widget* _sender)

apps/openmw/mwgui/scrollwindow.hpp

@@ -15,6 +15,7 @@ namespace MWGui
 
             void open (MWWorld::Ptr scroll);
             void setTakeButtonShow(bool show);
+            void setInventoryAllowed(bool allowed);
 
         protected:
             void onCloseButtonClicked (MyGUI::Widget* _sender);
@@ -26,6 +27,10 @@ namespace MWGui
             MyGUI::ScrollView* mTextView;
 
             MWWorld::Ptr mScroll;
+
+            bool mTakeButtonShow;
+            bool mTakeButtonAllowed;
+
     };
 
 }

apps/openmw/mwgui/tradewindow.cpp

@@ -19,12 +19,17 @@
 
 #include "inventorywindow.hpp"
 
+static const float BALANCE_CHANGE_INITIAL_PAUSE = 0.5; // in seconds
+static const float BALANCE_CHANGE_INTERVAL = 0.1; // in seconds
+
 namespace MWGui
 {
     TradeWindow::TradeWindow(MWBase::WindowManager& parWindowManager) :
         WindowBase("openmw_trade_window.layout", parWindowManager)
         , ContainerBase(NULL) // no drag&drop
         , mCurrentBalance(0)
+        , mBalanceButtonsState(BBS_None)
+        , mBalanceChangePause(0.0)
     {
         MyGUI::ScrollView* itemView;
         MyGUI::Widget* containerWidget;
@@ -59,8 +64,10 @@ namespace MWGui
 
         mCancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TradeWindow::onCancelButtonClicked);
         mOfferButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TradeWindow::onOfferButtonClicked);
-        mIncreaseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TradeWindow::onIncreaseButtonClicked);
+        mIncreaseButton->eventMouseButtonPressed += MyGUI::newDelegate(this, &TradeWindow::onIncreaseButtonPressed);
-        mDecreaseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TradeWindow::onDecreaseButtonClicked);
+        mIncreaseButton->eventMouseButtonReleased += MyGUI::newDelegate(this, &TradeWindow::onBalanceButtonReleased);
+        mDecreaseButton->eventMouseButtonPressed += MyGUI::newDelegate(this, &TradeWindow::onDecreaseButtonPressed);
+        mDecreaseButton->eventMouseButtonReleased += MyGUI::newDelegate(this, &TradeWindow::onBalanceButtonReleased);
 
         setCoord(400, 0, 400, 300);
 
@@ -143,6 +150,21 @@ namespace MWGui
         }
     }
 
+    void TradeWindow::onFrame(float frameDuration)
+    {
+        if (!mMainWidget->getVisible() || mBalanceButtonsState == BBS_None)
+            return;
+
+        mBalanceChangePause -= frameDuration;
+        if (mBalanceChangePause < 0.0) {
+            mBalanceChangePause += BALANCE_CHANGE_INTERVAL;
+            if (mBalanceButtonsState == BBS_Increase)
+                onIncreaseButtonTriggered();
+            else if (mBalanceButtonsState == BBS_Decrease)
+                onDecreaseButtonTriggered();
+        }
+    }
+
     void TradeWindow::onOfferButtonClicked(MyGUI::Widget* _sender)
     {
         const MWWorld::Store<ESM::GameSetting> &gmst =
@@ -271,14 +293,33 @@ namespace MWGui
         mWindowManager.removeGuiMode(GM_Barter);
     }
 
-    void TradeWindow::onIncreaseButtonClicked(MyGUI::Widget* _sender)
+    void TradeWindow::onIncreaseButtonPressed(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
+    {
+        mBalanceButtonsState = BBS_Increase;
+        mBalanceChangePause = BALANCE_CHANGE_INITIAL_PAUSE;
+        onIncreaseButtonTriggered();
+    }
+
+    void TradeWindow::onDecreaseButtonPressed(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id)
+    {
+        mBalanceButtonsState = BBS_Decrease;
+        mBalanceChangePause = BALANCE_CHANGE_INITIAL_PAUSE;
+        onDecreaseButtonTriggered();
+    }
+
+    void TradeWindow::onBalanceButtonReleased(MyGUI::Widget *_sender, int _left, int _top, MyGUI::MouseButton _id)
+    {
+        mBalanceButtonsState = BBS_None;
+    }
+
+    void TradeWindow::onIncreaseButtonTriggered()
     {
         if(mCurrentBalance<=-1) mCurrentBalance -= 1;
         if(mCurrentBalance>=1) mCurrentBalance += 1;
         updateLabels();
     }
 
-    void TradeWindow::onDecreaseButtonClicked(MyGUI::Widget* _sender)
+    void TradeWindow::onDecreaseButtonTriggered()
     {
         if(mCurrentBalance<-1) mCurrentBalance += 1;
         if(mCurrentBalance>1) mCurrentBalance -= 1;

apps/openmw/mwgui/tradewindow.hpp

@@ -34,6 +34,8 @@ namespace MWGui
 
             void addOrRemoveGold(int gold);
 
+            void onFrame(float frameDuration);
+
         protected:
             MyGUI::Button* mFilterAll;
             MyGUI::Button* mFilterWeapon;
@@ -57,12 +59,24 @@ namespace MWGui
             int mCurrentBalance;
             int mCurrentMerchantOffer;
 
+            enum BalanceButtonsState {
+                BBS_None,
+                BBS_Increase,
+                BBS_Decrease
+            } mBalanceButtonsState;
+            /// pause before next balance change will trigger while user holds +/- button pressed
+            float mBalanceChangePause;
+
             void onWindowResize(MyGUI::Window* _sender);
             void onFilterChanged(MyGUI::Widget* _sender);
             void onOfferButtonClicked(MyGUI::Widget* _sender);
             void onCancelButtonClicked(MyGUI::Widget* _sender);
-            void onIncreaseButtonClicked(MyGUI::Widget* _sender);
+            void onIncreaseButtonPressed(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id);
-            void onDecreaseButtonClicked(MyGUI::Widget* _sender);
+            void onDecreaseButtonPressed(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id);
+            void onBalanceButtonReleased(MyGUI::Widget* _sender, int _left, int _top, MyGUI::MouseButton _id);
+
+            void onIncreaseButtonTriggered();
+            void onDecreaseButtonTriggered();
 
             // don't show items that the NPC has equipped in his trade-window.
             virtual bool ignoreEquippedItems() { return true; }

apps/openmw/mwgui/travelwindow.cpp

@@ -132,6 +132,8 @@ namespace MWGui
         if (mWindowManager.getInventoryWindow()->getPlayerGold()<price)
             return;
 
+        mWindowManager.getTradeWindow ()->addOrRemoveGold (-price);
+
         MWBase::Environment::get().getWorld ()->getFader ()->fadeOut(1);
         MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
         ESM::Position pos = *_sender->getUserData<ESM::Position>();

apps/openmw/mwgui/waitdialog.cpp

@@ -1,5 +1,7 @@
 #include "waitdialog.hpp"
 
+#include <cmath>
+
 #include <boost/lexical_cast.hpp>
 
 #include <libs/openengine/ogre/fader.hpp>
@@ -14,6 +16,7 @@
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/class.hpp"
 
+#include "../mwmechanics/creaturestats.hpp"
 #include "../mwmechanics/npcstats.hpp"
 
 #include "widgets.hpp"
@@ -132,21 +135,62 @@ namespace MWGui
 
     void WaitDialog::onUntilHealedButtonClicked(MyGUI::Widget* sender)
     {
-        startWaiting();
+        // we need to sleep for a specific time, and since that isn't calculated yet, we'll do it here
+        // I'm making the assumption here that the # of hours rested is calculated when rest is started
+        // TODO: the rougher logic here (calculating the hourly deltas) should really go into helper funcs elsewhere
+        MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
+        MWMechanics::CreatureStats stats = MWWorld::Class::get(player).getCreatureStats(player);
+        const MWWorld::ESMStore& store = MWBase::Environment::get().getWorld()->getStore();
+        
+        float hourlyHealthDelta  = stats.getAttribute(ESM::Attribute::Endurance).getModified() * 0.1;
+        
+        bool stunted = (stats.getMagicEffects().get(MWMechanics::EffectKey(136)).mMagnitude > 0);
+        float fRestMagicMult = store.get<ESM::GameSetting>().find("fRestMagicMult")->getFloat();
+        float hourlyMagickaDelta = fRestMagicMult * stats.getAttribute(ESM::Attribute::Intelligence).getModified();
+        
+        // this massive duplication is why it has to be put into helper functions instead
+        float fFatigueReturnBase = store.get<ESM::GameSetting>().find("fFatigueReturnBase")->getFloat();
+        float fFatigueReturnMult = store.get<ESM::GameSetting>().find("fFatigueReturnMult")->getFloat();
+        float fEndFatigueMult = store.get<ESM::GameSetting>().find("fEndFatigueMult")->getFloat();
+        float capacity = MWWorld::Class::get(player).getCapacity(player);
+        float encumbrance = MWWorld::Class::get(player).getEncumbrance(player);
+        float normalizedEncumbrance = (capacity == 0 ? 1 : encumbrance/capacity);
+        if (normalizedEncumbrance > 1)
+            normalizedEncumbrance = 1;
+        float hourlyFatigueDelta = fFatigueReturnBase + fFatigueReturnMult * (1 - normalizedEncumbrance);
+        hourlyFatigueDelta *= 3600 * fEndFatigueMult * stats.getAttribute(ESM::Attribute::Endurance).getModified();
+        
+        float healthHours  = hourlyHealthDelta  >= 0.0
+                             ? (stats.getHealth().getBase() - stats.getHealth().getCurrent()) / hourlyHealthDelta
+                             : 1.0f;
+        float magickaHours = stunted ? 0.0 :
+                              hourlyMagickaDelta >= 0.0
+                              ? (stats.getMagicka().getBase() - stats.getMagicka().getCurrent()) / hourlyMagickaDelta
+                              : 1.0f;
+        float fatigueHours = hourlyFatigueDelta >= 0.0
+                             ? (stats.getFatigue().getBase() - stats.getFatigue().getCurrent()) / hourlyFatigueDelta
+                             : 1.0f;
+        
+        int autoHours = int(std::ceil( std::max(std::max(healthHours, magickaHours), std::max(fatigueHours, 1.0f)) )); // this should use a variadic max if possible
+        
+        startWaiting(autoHours);
     }
 
     void WaitDialog::onWaitButtonClicked(MyGUI::Widget* sender)
     {
-        startWaiting();
+        startWaiting(mManualHours);
     }
 
-    void WaitDialog::startWaiting ()
+    void WaitDialog::startWaiting(int hoursToWait)
     {
         MWBase::Environment::get().getWorld ()->getFader ()->fadeOut(0.2);
         setVisible(false);
         mProgressBar.setVisible (true);
+        
         mWaiting = true;
         mCurHour = 0;
+        mHours = hoursToWait;
+        
         mRemainingTime = 0.05;
         mProgressBar.setProgress (0, mHours);
     }
@@ -159,7 +203,7 @@ namespace MWGui
     void WaitDialog::onHourSliderChangedPosition(MyGUI::ScrollBar* sender, size_t position)
     {
         mHourText->setCaptionWithReplacing (boost::lexical_cast<std::string>(position+1) + " #{sRestMenu2}");
-        mHours = position+1;
+        mManualHours = position+1;
     }
 
     void WaitDialog::setCanRest (bool canRest)
@@ -181,9 +225,9 @@ namespace MWGui
 
         mRemainingTime -= dt;
 
-        if (mRemainingTime < 0)
+        while (mRemainingTime < 0)
         {
-            mRemainingTime = 0.05;
+            mRemainingTime += 0.05;
             ++mCurHour;
             mProgressBar.setProgress (mCurHour, mHours);
 
@@ -197,6 +241,7 @@ namespace MWGui
 
         if (mCurHour > mHours)
             stopWaiting();
+
     }
 
     void WaitDialog::stopWaiting ()

apps/openmw/mwgui/waitdialog.hpp

@@ -47,6 +47,7 @@ namespace MWGui
         bool mSleeping;
         int mCurHour;
         int mHours;
+        int mManualHours; // stores the hours to rest selected via slider
         float mRemainingTime;
 
         WaitDialogProgressBar mProgressBar;
@@ -58,7 +59,7 @@ namespace MWGui
 
         void setCanRest(bool canRest);
 
-        void startWaiting();
+        void startWaiting(int hoursToWait);
         void stopWaiting();
     };
 

apps/openmw/mwgui/windowmanagerimp.cpp

@@ -109,7 +109,6 @@ WindowManager::WindowManager(
   , mHudEnabled(true)
   , mTranslationDataStorage (translationDataStorage)
 {
-
     // Set up the GUI system
     mGuiManager = new OEngine::GUI::MyGUIManager(mOgre->getWindow(), mOgre->getScene(), false, logpath);
     mGui = mGuiManager->getGui();
@@ -196,6 +195,9 @@ WindowManager::WindowManager(
     unsetSelectedSpell();
     unsetSelectedWeapon();
 
+    if (newGame)
+        disallowAll ();
+
     // Set up visibility
     updateVisible();
 }
@@ -613,6 +615,7 @@ void WindowManager::onFrame (float frameDuration)
     mHud->onFrame(frameDuration);
 
     mTrainingWindow->onFrame (frameDuration);
+    mTradeWindow->onFrame(frameDuration);
 
     mTrainingWindow->checkReferenceAvailable();
     mDialogueWindow->checkReferenceAvailable();
@@ -942,12 +945,23 @@ bool WindowManager::isAllowed (GuiWindow wnd) const
 void WindowManager::allow (GuiWindow wnd)
 {
     mAllowed = (GuiWindow)(mAllowed | wnd);
+
+    if (wnd & GW_Inventory)
+    {
+        mBookWindow->setInventoryAllowed (true);
+        mScrollWindow->setInventoryAllowed (true);
+    }
+
     updateVisible();
 }
 
 void WindowManager::disallowAll()
 {
     mAllowed = GW_None;
+
+    mBookWindow->setInventoryAllowed (false);
+    mScrollWindow->setInventoryAllowed (false);
+
     updateVisible();
 }
 

apps/openmw/mwinput/inputmanagerimp.cpp

@@ -51,7 +51,6 @@ namespace MWInput
         , mUIYMultiplier (Settings::Manager::getFloat("ui y multiplier", "Input"))
         , mPreviewPOVDelay(0.f)
         , mTimeIdle(0.f)
-        , mEnterPressed(false)
     {
         Ogre::RenderWindow* window = ogre.getWindow ();
         size_t windowHnd;
@@ -240,10 +239,6 @@ namespace MWInput
 
     void InputManager::update(float dt, bool loading)
     {
-        // Pressing enter when a messagebox is prompting for "ok" will activate the ok button 
-        if(mEnterPressed && MWBase::Environment::get().getWindowManager()->isGuiMode() && MWBase::Environment::get().getWindowManager()->getMode() == MWGui::GM_InterMessageBox)
-            MWBase::Environment::get().getWindowManager()->enterPressed();
-
         // Tell OIS to handle all input events
         mKeyboard->capture();
         mMouse->capture();
@@ -431,8 +426,13 @@ namespace MWInput
 
     bool InputManager::keyPressed( const OIS::KeyEvent &arg )
     {
-        if(arg.key == OIS::KC_RETURN && MWBase::Environment::get().getWindowManager()->isGuiMode() && MWBase::Environment::get().getWindowManager()->getMode() != MWGui::GM_Console)
+        if(arg.key == OIS::KC_RETURN
-            mEnterPressed = true;
+            && MWBase::Environment::get().getWindowManager()->isGuiMode()
+            && MWBase::Environment::get().getWindowManager()->getMode() == MWGui::GM_InterMessageBox )
+        {
+            // Pressing enter when a messagebox is prompting for "ok" will activate the ok button
+            MWBase::Environment::get().getWindowManager()->enterPressed();
+        }
 
         mInputCtrl->keyPressed (arg);
         unsigned int text = arg.text;
@@ -450,9 +450,6 @@ namespace MWInput
 
     bool InputManager::keyReleased( const OIS::KeyEvent &arg )
     {
-        if(arg.key == OIS::KC_RETURN)
-            mEnterPressed = false;
-
         mInputCtrl->keyReleased (arg);
 
         MyGUI::InputManager::getInstance().injectKeyRelease(MyGUI::KeyCode::Enum(arg.key));
@@ -590,10 +587,14 @@ namespace MWInput
         // Toggle between game mode and inventory mode
         if(gameMode)
             mWindows.pushGuiMode(MWGui::GM_Inventory);
-        else if(mWindows.getMode() == MWGui::GM_Inventory)
+        else
+        {
+            MWGui::GuiMode mode = mWindows.getMode();
+            if(mode == MWGui::GM_Inventory || mode == MWGui::GM_Container)
                 mWindows.popGuiMode();
+        }
 
-        // .. but don't touch any other mode.
+        // .. but don't touch any other mode, except container.
     }
 
     void InputManager::toggleConsole()
@@ -634,10 +635,13 @@ namespace MWInput
     {
         if (!mWindows.isGuiMode ())
             mWindows.pushGuiMode (MWGui::GM_QuickKeysMenu);
+        else if (mWindows.getMode () == MWGui::GM_QuickKeysMenu)
+            mWindows.removeGuiMode (MWGui::GM_QuickKeysMenu);
     }
 
     void InputManager::activate()
     {
+        if (mControlSwitch["playercontrols"])
             mEngine.activate();
     }
 

apps/openmw/mwinput/inputmanagerimp.hpp

@@ -151,8 +151,6 @@ namespace MWInput
 
         std::map<std::string, bool> mControlSwitch;
 
-        bool mEnterPressed;
-
     private:
         void adjustMouseRegion(int width, int height);
 

apps/openmw/mwscript/containerextensions.cpp

@@ -21,6 +21,7 @@
 #include "../mwworld/containerstore.hpp"
 #include "../mwworld/actionequip.hpp"
 #include "../mwworld/inventorystore.hpp"
+#include "../mwworld/player.hpp"
 
 #include "interpretercontext.hpp"
 #include "ref.hpp"
@@ -47,6 +48,10 @@ namespace MWScript
                     if (count<0)
                         throw std::runtime_error ("second argument for AddItem must be non-negative");
 
+                    // no-op
+                    if (count == 0)
+                        return;
+
                     MWWorld::ManualRef ref (MWBase::Environment::get().getWorld()->getStore(), item);
 
                     ref.getPtr().getRefData().setCount (count);
@@ -60,6 +65,26 @@ namespace MWScript
                     }
 
                     MWWorld::Class::get (ptr).getContainerStore (ptr).add (ref.getPtr());
+
+                    // Spawn a messagebox (only for items added to player's inventory)
+                    if (ptr == MWBase::Environment::get().getWorld ()->getPlayer ().getPlayer())
+                    {
+                        // The two GMST entries below expand to strings informing the player of what, and how many of it has been added to their inventory
+                        std::string msgBox;
+                        std::string itemName = MWWorld::Class::get(ref.getPtr()).getName(ref.getPtr());
+                        if (count == 1)
+                        {
+                            msgBox = MyGUI::LanguageManager::getInstance().replaceTags("#{sNotifyMessage60}");
+                            msgBox = boost::str(boost::format(msgBox) % itemName);
+                        }
+                        else
+                        {
+                            msgBox = MyGUI::LanguageManager::getInstance().replaceTags("#{sNotifyMessage61}");
+                            msgBox = boost::str(boost::format(msgBox) % count % itemName);
+                        }
+
+                        MWBase::Environment::get().getWindowManager()->messageBox(msgBox, std::vector<std::string>());
+                    }
                 }
         };
 
@@ -105,9 +130,15 @@ namespace MWScript
                     if (count<0)
                         throw std::runtime_error ("second argument for RemoveItem must be non-negative");
 
+                    // no-op
+                    if (count == 0)
+                        return;
+
                     MWWorld::ContainerStore& store = MWWorld::Class::get (ptr).getContainerStore (ptr);
                     
                     std::string itemName = "";
+
+                    // originalCount holds the total number of items to remove, count holds the remaining number of items to remove
                     Interpreter::Type_Integer originalCount = count;
 
                     for (MWWorld::ContainerStoreIterator iter (store.begin()); iter!=store.end() && count;
@@ -130,28 +161,26 @@ namespace MWScript
                         }
                     }
                   
-                    /* The two GMST entries below expand to strings informing the player of what, and how many of it has been removed from their inventory */
+                    // Spawn a messagebox (only for items added to player's inventory)
+                    if (ptr == MWBase::Environment::get().getWorld ()->getPlayer ().getPlayer())
+                    {
+                        // The two GMST entries below expand to strings informing the player of what, and how many of it has been removed from their inventory
                         std::string msgBox;
-                    if(originalCount - count > 1)
+                        int numRemoved = (originalCount - count);
+                        if(numRemoved > 1)
                         {
                             msgBox = MyGUI::LanguageManager::getInstance().replaceTags("#{sNotifyMessage63}");
-                        std::stringstream temp;
+                            msgBox = boost::str (boost::format(msgBox) % numRemoved % itemName);
-                        temp << boost::format(msgBox) % (originalCount - count) % itemName;
-                        msgBox = temp.str();
                         }
                         else
                         {
                             msgBox = MyGUI::LanguageManager::getInstance().replaceTags("#{sNotifyMessage62}");
-                        std::stringstream temp;
+                            msgBox = boost::str (boost::format(msgBox) % itemName);
-                        temp << boost::format(msgBox) % itemName;
-                        msgBox = temp.str();
                         }
 
-                    if(originalCount - count > 0)
+                        if (numRemoved > 0)
                             MWBase::Environment::get().getWindowManager()->messageBox(msgBox, std::vector<std::string>());
-
+                    }
-                    // To be fully compatible with original Morrowind, we would need to check if
-                    // count is >= 0 here and throw an exception. But let's be tollerant instead.
                 }
         };
 

apps/openmw/mwworld/actiontake.cpp

@@ -14,9 +14,6 @@ namespace MWWorld
 
     void ActionTake::executeImp (const Ptr& actor)
     {
-        if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
-            return;
-
         // insert into player's inventory
         MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPtr ("player", true);
 

apps/openmw/mwworld/esmstore.cpp

@@ -3,7 +3,7 @@
 #include <set>
 #include <iostream>
 
-#include <boost/filesystem/v3/operations.hpp>
+#include <boost/filesystem/operations.hpp>
 
 namespace MWWorld
 {

components/esm/loadcell.hpp

@@ -77,7 +77,7 @@ public:
   std::string mKey, mTrap; // Key and trap ID names, if any
 
   // No idea - occurs ONCE in Morrowind.esm, for an activator
-  char mUnam;
+  signed char mUnam;
 
   // Track deleted references. 0 - not deleted, 1 - deleted, but respawns, 2 - deleted and does not respawn.
   int mDeleted;

components/esm/loaddial.hpp

@@ -30,7 +30,7 @@ struct Dialogue
     };
 
     std::string mId;
-    char mType;
+    signed char mType;
     std::vector<DialInfo> mInfo;
 
     void load(ESMReader &esm);

components/to_utf8/tables_gen.hpp

@@ -8,7 +8,7 @@ namespace ToUTF8
 /// Central European and Eastern European languages that use Latin script,
 /// such as Polish, Czech, Slovak, Hungarian, Slovene, Bosnian, Croatian,
 /// Serbian (Latin script), Romanian and Albanian.
-static char windows_1250[] =
+static signed char windows_1250[] =
 {
     1, 0, 0, 0, 0, 0,
     1, 1, 0, 0, 0, 0,
@@ -270,7 +270,7 @@ static char windows_1250[] =
 
 /// Cyrillic alphabet such as Russian, Bulgarian, Serbian Cyrillic
 /// and other languages
-static char windows_1251[] =
+static signed char windows_1251[] =
 {
     1, 0, 0, 0, 0, 0,
     1, 1, 0, 0, 0, 0,
@@ -531,7 +531,7 @@ static char windows_1251[] =
 };
 
 /// Latin alphabet used by English and some other Western languages
-static char windows_1252[] =
+static signed char windows_1252[] =
 {
     1, 0, 0, 0, 0, 0,
     1, 1, 0, 0, 0, 0,

components/to_utf8/to_utf8.cpp

@@ -216,7 +216,7 @@ void Utf8Encoder::copyFromArray(unsigned char ch, char* &out)
         return;
     }
 
-    const char *in = translationArray + ch*6;
+    const signed char *in = translationArray + ch*6;
     int len = *(in++);
     for (int i=0; i<len; i++)
         *(out++) = *(in++);

components/to_utf8/to_utf8.hpp

@@ -47,7 +47,7 @@ namespace ToUTF8
             void copyFromArray2(const char*& chp, char* &out);
 
             std::vector<char> mOutput;
-            char* translationArray;
+            signed char* translationArray;
     };
 }
 

files/opencs/resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>opencs.png</file>
+    </qresource>
+</RCC>