Merge branch 'master' of https://github.com/OpenMW/openmw into osg

Conflicts:
	apps/launcher/graphicspage.cpp
	apps/opencs/editor.cpp
	apps/opencs/model/doc/document.cpp
	apps/opencs/view/render/cell.cpp
	apps/opencs/view/render/mousestate.cpp
	apps/opencs/view/render/textoverlay.cpp
	apps/opencs/view/render/worldspacewidget.cpp
	apps/openmw/mwclass/creature.cpp
	apps/openmw/mwclass/npc.cpp
	apps/openmw/mwgui/inventorywindow.cpp
	apps/openmw/mwgui/loadingscreen.cpp
	apps/openmw/mwgui/mapwindow.cpp
	apps/openmw/mwgui/pickpocketitemmodel.cpp
	apps/openmw/mwgui/waitdialog.cpp
	apps/openmw/mwmechanics/combat.cpp
	apps/openmw/mwmechanics/mechanicsmanagerimp.cpp
	apps/openmw/mwrender/globalmap.cpp
	apps/openmw/mwworld/physicssystem.cpp
	apps/openmw/mwworld/refdata.cpp
	apps/openmw/mwworld/scene.cpp
	apps/openmw/mwworld/worldimp.cpp
	components/sdlutil/sdlinputwrapper.cpp
	extern/shiny/Main/Factory.cpp
	extern/shiny/Main/MaterialInstance.cpp
	extern/shiny/Main/Platform.cpp
	extern/shiny/Main/ShaderSet.cpp

AUTHORS.md

@@ -98,6 +98,7 @@ Programmers
     Sebastian Wick (swick)
     Sergey Shambir
     sir_herrbatka
+    smbas
     Stefan Galowicz (bogglez)
     Stanislav Bobrov (Jiub)
     Sylvain Thesnieres (Garvek)
@@ -109,6 +110,13 @@ Programmers
     Vincent Heuken
     vocollapse
 
+Manual
+------
+
+    Bodillium
+    Cramal
+    sir_herrbatka
+
 Packagers
 ---------
 

CHANGELOG.md

@@ -1,3 +1,49 @@
+0.36.0
+------
+
+    Bug #923: Editor: Operations-Multithreading is broken
+    Bug #1317: Erene Llenim in Seyda Neen does not walk around
+    Bug #1405: Water rendering glitch near Seyda Neen lighthouse
+    Bug #1621: "Error Detecting Morrowind Installation" in the default directory
+    Bug #2216: Creating a clone of the player stops you moving.
+    Bug #2387: Casting bound weapon spell doesn't switch to "ready weapon" mode
+    Bug #2407: Default to (0, 0) when "unknown cell" is encountered.
+    Bug #2411: enchanted item charges don't update/refresh if spell list window is pinned open
+    Bug #2428: Editor: cloning / creating new container class results in invalid omwaddon file - openmw-0.35
+    Bug #2429: Editor - cloning omits some values or sets different values than the original has
+    Bug #2430: NPC with negative fatigue don't fall (LGNPC Vivec, Foreign Quarter v2.21)
+    Bug #2432: Error on startup with Uvirith's Legacy enabled
+    Bug #2435: Editor: changed entries in the objects window are not shown as such
+    Bug #2437: Editor: changing an entry of a container/NPC/clothing/ingredient/globals will not be saved in the omwaddon file
+    Bug #2447: Editor doesn't save terrain information
+    Bug #2451: Editor not listing files with accented characters
+    Bug #2453: Chargen: sex, race and hair sliders not initialized properly
+    Bug #2459: Minor terrain clipping through statics due to difference in triangle alignment
+    Bug #2461: Invisible sound mark has collision in Sandus Ancestral Tomb
+    Bug #2465: tainted gold stack
+    Bug #2475: cumulative stacks of 100 point fortify skill speechcraft boosts do not apply correctly
+    Bug #2498: Editor: crash when issuing undo command after the table subview is closed
+    Bug #2500: Editor: object table - can't undo delete record
+    Bug #2518: OpenMW detect spell returns false positives
+    Bug #2521: NPCs don't react to stealing when inventory menu is open.
+    Bug #2525: Can't click on red dialogue choice [rise of house telvanni][60fffec]
+    Bug #2530: GetSpellEffects not working as in vanilla
+    Bug #2557: Crash on first launch after choosing "Run installation wizard"
+    Feature #139: Editor: Global Search & Replace
+    Feature #1219: Editor: Add dialogue mode only columns
+    Feature #2024: Hotkey for hand to hand (i.e. unequip any weapon)
+    Feature #2119: "Always Sneak" key bind
+    Feature #2262: Editor: Handle moved instances
+    Feature #2425: Editor: Add start script table
+    Feature #2426: Editor: start script record verifier
+    Feature #2480: Launcher: Multiselect entries in the Data Files list
+    Feature #2505: Editor: optionally show a line number column in the script editor
+    Feature #2512: Editor: Offer use of monospace fonts in the script editor as an option
+    Feature #2514: Editor: focus on ID input field on clone/add
+    Feature #2519: it is not possible to change icons that appear on the map after casting the Detect <animal | enchantment | key> spells
+    Task #2460: OS X: Use Application Support directory as user data path
+    Task #2516: Editor: Change References / Referenceables terminology
+
 0.35.1
 ------
 

CMakeLists.txt

@@ -19,8 +19,8 @@ set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/)
 message(STATUS "Configuring OpenMW...")
 
 set(OPENMW_VERSION_MAJOR 0)
-set(OPENMW_VERSION_MINOR 35)
+set(OPENMW_VERSION_MINOR 36)
-set(OPENMW_VERSION_RELEASE 1)
+set(OPENMW_VERSION_RELEASE 0)
 
 set(OPENMW_VERSION_COMMITHASH "")
 set(OPENMW_VERSION_TAGHASH "")
@@ -263,7 +263,7 @@ endif()
 
 # CXX Compiler settings
 if (CMAKE_CXX_COMPILER_ID STREQUAL GNU OR CMAKE_CXX_COMPILER_ID STREQUAL Clang)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-parameter -Wno-reorder -std=c++98 -pedantic -Wno-long-long")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-parameter -std=c++98 -pedantic -Wno-long-long")
 
     if (CMAKE_CXX_COMPILER_ID STREQUAL Clang AND NOT APPLE)
         execute_process(COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE CLANG_VERSION)

README.md

@@ -6,7 +6,7 @@ OpenMW
 OpenMW is an attempt at recreating the engine for the popular role-playing game
 Morrowind by Bethesda Softworks. You need to own and install the original game for OpenMW to work.
 
-* Version: 0.35.1
+* Version: 0.36.0
 * License: GPL (see docs/license/GPL3.txt for more information)
 * Website: http://www.openmw.org
 * IRC: #openmw on irc.freenode.net

apps/launcher/graphicspage.cpp

@@ -33,9 +33,9 @@ QString getAspect(int x, int y)
 }
 
 Launcher::GraphicsPage::GraphicsPage(Files::ConfigurationManager &cfg, GraphicsSettings &graphicsSetting, QWidget *parent)
-    : mCfgMgr(cfg)
+    : QWidget(parent)
+    , mCfgMgr(cfg)
     , mGraphicsSettings(graphicsSetting)
-    , QWidget(parent)
 {
     setObjectName ("GraphicsPage");
     setupUi(this);

apps/launcher/main.cpp

@@ -59,14 +59,16 @@ int main(int argc, char *argv[])
 
         Launcher::MainDialog mainWin;
 
-        if (!mainWin.showFirstRunDialog())
+        Launcher::FirstRunDialogResult result = mainWin.showFirstRunDialog();
+        if (result == Launcher::FirstRunDialogResultFailure)
             return 0;
 
     //    if (!mainWin.setup()) {
     //        return 0;
     //    }
 
-        mainWin.show();
+        if (result == Launcher::FirstRunDialogResultContinue)
+            mainWin.show();
 
         int returnValue = app.exec();
         SDL_Quit();

apps/launcher/maindialog.cpp

@@ -148,10 +148,10 @@ void Launcher::MainDialog::createPages()
 
 }
 
-bool Launcher::MainDialog::showFirstRunDialog()
+Launcher::FirstRunDialogResult Launcher::MainDialog::showFirstRunDialog()
 {
     if (!setupLauncherSettings())
-        return false;
+        return FirstRunDialogResultFailure;
 
     if (mLauncherSettings.value(QString("General/firstrun"), QString("true")) == QLatin1String("true"))
     {
@@ -176,14 +176,14 @@ bool Launcher::MainDialog::showFirstRunDialog()
         if (msgBox.clickedButton() == wizardButton)
         {
             if (!mWizardInvoker->startProcess(QLatin1String("openmw-wizard"), false)) {
-                return false;
+                return FirstRunDialogResultFailure;
             } else {
-                return true;
+                return FirstRunDialogResultWizard;
             }
         }
     }
 
-    return setup();
+    return setup() ? FirstRunDialogResultContinue : FirstRunDialogResultFailure;
 }
 
 bool Launcher::MainDialog::setup()

apps/launcher/maindialog.hpp

@@ -31,6 +31,13 @@ namespace Launcher
     class UnshieldThread;
     class SettingsPage;
 
+    enum FirstRunDialogResult
+    {
+        FirstRunDialogResultFailure,
+        FirstRunDialogResultContinue,
+        FirstRunDialogResultWizard
+    };
+
 #ifndef WIN32
     bool expansions(Launcher::UnshieldThread& cd);
 #endif
@@ -44,7 +51,7 @@ namespace Launcher
         ~MainDialog();
 
         bool setup();
-        bool showFirstRunDialog();
+        FirstRunDialogResult showFirstRunDialog();
 
         bool reloadSettings();
         bool writeSettings();

apps/launcher/settingspage.cpp

@@ -18,10 +18,10 @@ using namespace Process;
 Launcher::SettingsPage::SettingsPage(Files::ConfigurationManager &cfg,
                                      Config::GameSettings &gameSettings,
                                      Config::LauncherSettings &launcherSettings, MainDialog *parent)
-    : mCfgMgr(cfg)
+    : QWidget(parent)
+    , mCfgMgr(cfg)
     , mGameSettings(gameSettings)
     , mLauncherSettings(launcherSettings)
-    , QWidget(parent)
     , mMain(parent)
 {
     setupUi(this);

apps/opencs/CMakeLists.txt

@@ -46,7 +46,7 @@ opencs_units_noqt (model/tools
 
 opencs_units (view/doc
     viewmanager view operations operation subview startup filedialog newgame
-    filewidget adjusterwidget loader globaldebugprofilemenu runlogsubview
+    filewidget adjusterwidget loader globaldebugprofilemenu runlogsubview sizehint
     )
 
 

apps/opencs/editor.cpp

@@ -14,10 +14,11 @@
 #include "model/doc/document.hpp"
 #include "model/world/data.hpp"
 
+
 CS::Editor::Editor ()
 : mUserSettings (mCfgMgr), mDocumentManager (mCfgMgr),
-  mViewManager (mDocumentManager),
+  mViewManager (mDocumentManager), mPid(""),
-  mIpcServerName ("org.openmw.OpenCS"), mServer(NULL), mClientSocket(NULL), mPid(""), mLock()
+  mLock(), mIpcServerName ("org.openmw.OpenCS"), mServer(NULL), mClientSocket(NULL)
 {
     std::pair<Files::PathContainer, std::vector<std::string> > config = readConfig();
 

apps/opencs/model/doc/document.cpp

@@ -2250,11 +2250,12 @@ CSMDoc::Document::Document (const VFS::Manager* vfs, const Files::ConfigurationM
     ToUTF8::FromType encoding, const CSMWorld::ResourcesManager& resourcesManager,
     const std::vector<std::string>& blacklistedScripts)
 : mVFS(vfs), mSavePath (savePath), mContentFiles (files), mNew (new_), mData (encoding, resourcesManager),
-  mTools (*this), mResDir(resDir),
+  mTools (*this),
   mProjectPath ((configuration.getUserDataPath() / "projects") /
   (savePath.filename().string() + ".project")),
   mSavingOperation (*this, mProjectPath, encoding),
   mSaving (&mSavingOperation),
+  mResDir(resDir),
   mRunner (mProjectPath)
 {
     if (mContentFiles.empty())

apps/opencs/model/filter/valuenode.cpp

@@ -9,7 +9,7 @@
 
 CSMFilter::ValueNode::ValueNode (int columnId, Type lowerType, Type upperType,
     double lower, double upper)
-: mColumnId (columnId), mLowerType (lowerType), mUpperType (upperType), mLower (lower), mUpper (upper){}
+: mColumnId (columnId), mLower (lower), mUpper (upper), mLowerType (lowerType), mUpperType (upperType){}
 
 bool CSMFilter::ValueNode::test (const CSMWorld::IdTableBase& table, int row,
     const std::map<int, int>& columns) const
@@ -27,7 +27,7 @@ bool CSMFilter::ValueNode::test (const CSMWorld::IdTableBase& table, int row,
     QVariant data = table.data (index);
 
     if (data.type()!=QVariant::Double && data.type()!=QVariant::Bool && data.type()!=QVariant::Int &&
-        data.type()!=QVariant::UInt)
+        data.type()!=QVariant::UInt && data.type()!=static_cast<QVariant::Type> (QMetaType::Float))
         return false;
 
     double value = data.toDouble();

apps/opencs/model/settings/connector.cpp

@@ -4,7 +4,7 @@
 
 CSMSettings::Connector::Connector(CSVSettings::View *master,
                                             QObject *parent)
-    : mMasterView (master), QObject(parent)
+    : QObject(parent), mMasterView (master)
 {}
 
 void CSMSettings::Connector::addSlaveView (CSVSettings::View *view,

apps/opencs/model/settings/usersettings.cpp

@@ -126,6 +126,24 @@ void CSMSettings::UserSettings::buildSettingModelDefaults()
         minWidth->setDefaultValue (325);
         minWidth->setRange (50, 10000);
         minWidth->setToolTip ("Minimum width of subviews.");
+
+        QString defaultScroll = "Scrollbar Only";
+        QStringList scrollValues = QStringList() << defaultScroll << "Grow Only" << "Grow then Scroll";
+
+        Setting *mainwinScroll = createSetting (Type_RadioButton, "mainwindow-scrollbar",
+            "Add a horizontal scrollbar to the main view window.");
+        mainwinScroll->setDefaultValue (defaultScroll);
+        mainwinScroll->setDeclaredValues (scrollValues);
+        mainwinScroll->setToolTip ("Scrollbar Only: Simple addition of scrollbars, the view window does not grow"
+            " automatically.\n"
+            "Grow Only: Original Editor behaviour. The view window grows as subviews are added. No scrollbars.\n"
+            "Grow then Scroll: The view window grows. The scrollbar appears once it cannot grow any further.");
+
+        Setting *grow = createSetting (Type_CheckBox, "grow-limit", "Grow Limit Screen");
+        grow->setDefaultValue ("false");
+        grow->setToolTip ("When \"Grow then Scroll\" option is selected, the window size grows to"
+            " the width of the virtual desktop. \nIf this option is selected the the window growth"
+            "is limited to the current screen.");
     }
 
     declareSection ("records", "Records");
@@ -189,6 +207,14 @@ void CSMSettings::UserSettings::buildSettingModelDefaults()
         shiftCtrlDoubleClick->setDeclaredValues (values);
         shiftCtrlDoubleClick->setDefaultValue (editRecordAndClose);
         shiftCtrlDoubleClick->setToolTip ("Action on shift control double click in table:<p>" + toolTip);
+
+        QString defaultValue = "Jump and Select";
+        QStringList jumpValues = QStringList() << defaultValue << "Jump Only" << "No Jump";
+
+        Setting *jumpToAdded = createSetting (Type_RadioButton, "jump-to-added",
+            "Jump to the added or cloned record.");
+        jumpToAdded->setDefaultValue (defaultValue);
+        jumpToAdded->setDeclaredValues (jumpValues);
     }
 
     declareSection ("search", "Search & Replace");

apps/opencs/model/tools/referenceablecheck.cpp

@@ -11,8 +11,8 @@ CSMTools::ReferenceableCheckStage::ReferenceableCheckStage(
     const CSMWorld::IdCollection<ESM::Faction>& faction)
     :
     mReferencables(referenceable),
-    mClasses(classes),
     mRaces(races),
+    mClasses(classes),
     mFactions(faction),
     mPlayerPresent(false)
 {

apps/opencs/model/tools/tools.cpp

@@ -103,8 +103,8 @@ CSMDoc::OperationHolder *CSMTools::Tools::getVerifier()
 }
 
 CSMTools::Tools::Tools (CSMDoc::Document& document)
-: mDocument (document), mData (document.getData()), mVerifierOperation (0), mNextReportNumber (0),
+: mDocument (document), mData (document.getData()), mVerifierOperation (0),
-  mSearchOperation (0)
+  mSearchOperation (0), mNextReportNumber (0)
 {
     // index 0: load error log
     mReports.insert (std::make_pair (mNextReportNumber++, new ReportModel));

apps/opencs/model/world/columnbase.cpp

@@ -3,7 +3,7 @@
 #include "columns.hpp"
 
 CSMWorld::ColumnBase::ColumnBase (int columnId, Display displayType, int flags)
-    : mColumnId (columnId), mDisplayType (displayType), mFlags (flags)
+    : mColumnId (columnId), mFlags (flags), mDisplayType (displayType)
 {}
 
 CSMWorld::ColumnBase::~ColumnBase() {}
@@ -81,6 +81,9 @@ bool CSMWorld::ColumnBase::isId (Display display)
         Display_PartRefType,
         Display_AiPackageType,
         Display_YesNo,
+        Display_InfoCondFunc,
+        Display_InfoCondVar,
+        Display_InfoCondComp,
 
         Display_None
     };

apps/opencs/model/world/columnbase.hpp

@@ -116,6 +116,9 @@ namespace CSMWorld
             Display_PartRefType,
             Display_AiPackageType,
             Display_YesNo,
+            Display_InfoCondFunc,
+            Display_InfoCondVar,
+            Display_InfoCondComp,
 
             //top level columns that nest other columns
             Display_NestedHeader

apps/opencs/model/world/columns.cpp

@@ -172,7 +172,7 @@ namespace CSMWorld
             { ColumnId_Rank, "Rank" },
             { ColumnId_Gender, "Gender" },
             { ColumnId_PcRank, "PC Rank" },
-            { ColumnId_ReferenceableId, "Referenceable ID" },
+            { ColumnId_ReferenceableId, "Object ID" },
 
             { ColumnId_ContainerContent, "Content" },
             { ColumnId_ItemCount, "Count" },
@@ -274,6 +274,11 @@ namespace CSMWorld
             { ColumnId_SkillImpact, "Skills" },
 
             { ColumnId_InfoList, "Info List" },
+            { ColumnId_InfoCondition, "Info Conditions" },
+            { ColumnId_InfoCondFunc, "Function" },
+            { ColumnId_InfoCondVar, "Func/Variable" },
+            { ColumnId_InfoCondComp, "Comp" },
+            { ColumnId_InfoCondValue, "Value" },
             { ColumnId_OriginalCell, "Original Cell" },
 
             { ColumnId_UseValue1, "Use value 1" },
@@ -502,6 +507,18 @@ namespace
         "No", "Yes", 0
     };
 
+    static const char *sInfoCondFunc[] =
+    {
+        " ", "Function", "Global", "Local", "Journal",
+        "Item", "Dead", "Not ID", "Not Faction", "Not Class",
+        "Not Race", "Not Cell", "Not Local", 0
+    };
+
+    static const char *sInfoCondComp[] =
+    {
+        "!=", "<", "<=", "=", ">", ">=", 0
+    };
+
     const char **getEnumNames (CSMWorld::Columns::ColumnId column)
     {
         switch (column)
@@ -530,6 +547,10 @@ namespace
             case CSMWorld::Columns::ColumnId_PartRefType: return sPartRefType;
             case CSMWorld::Columns::ColumnId_AiPackageType: return sAiPackageType;
             case CSMWorld::Columns::ColumnId_AiWanderRepeat: return sAiWanderRepeat;
+            case CSMWorld::Columns::ColumnId_InfoCondFunc: return sInfoCondFunc;
+            // FIXME: don't have dynamic value enum delegate, use Display_String for now
+            //case CSMWorld::Columns::ColumnId_InfoCond: return sInfoCond;
+            case CSMWorld::Columns::ColumnId_InfoCondComp: return sInfoCondComp;
 
             default: return 0;
         }

apps/opencs/model/world/columns.hpp

@@ -264,8 +264,13 @@ namespace CSMWorld
             ColumnId_SkillImpact = 240, // impact from magic effects
 
             ColumnId_InfoList = 241,
+            ColumnId_InfoCondition = 242,
+            ColumnId_InfoCondFunc = 243,
+            ColumnId_InfoCondVar = 244,
+            ColumnId_InfoCondComp = 245,
+            ColumnId_InfoCondValue = 246,
 
-            ColumnId_OriginalCell = 242,
+            ColumnId_OriginalCell = 247,
 
             // Allocated to a separate value range, so we don't get a collision should we ever need
             // to extend the number of use values.

apps/opencs/model/world/commanddispatcher.cpp

@@ -83,7 +83,7 @@ std::vector<std::string> CSMWorld::CommandDispatcher::getRevertableRecords() con
 
 CSMWorld::CommandDispatcher::CommandDispatcher (CSMDoc::Document& document,
     const CSMWorld::UniversalId& id, QObject *parent)
-: QObject (parent), mDocument (document), mId (id), mLocked (false)
+: QObject (parent), mLocked (false), mDocument (document), mId (id)
 {}
 
 void CSMWorld::CommandDispatcher::setEditLock (bool locked)

apps/opencs/model/world/commands.cpp

@@ -14,7 +14,7 @@
 
 CSMWorld::ModifyCommand::ModifyCommand (QAbstractItemModel& model, const QModelIndex& index,
                                         const QVariant& new_, QUndoCommand* parent)
-: QUndoCommand (parent), mModel (&model), mIndex (index), mNew (new_)
+: QUndoCommand (parent), mModel (&model), mIndex (index), mNew (new_), mHasRecordState(false)
 {
     if (QAbstractProxyModel *proxy = dynamic_cast<QAbstractProxyModel *> (&model))
     {
@@ -27,6 +27,15 @@ CSMWorld::ModifyCommand::ModifyCommand (QAbstractItemModel& model, const QModelI
     }
     else
         setText ("Modify " + mModel->headerData (mIndex.column(), Qt::Horizontal, Qt::DisplayRole).toString());
+
+    // Remember record state before the modification
+    if (CSMWorld::IdTable *table = dynamic_cast<IdTable *>(mModel))
+    {
+        mHasRecordState = true;
+        int stateColumnIndex = table->findColumnIndex(Columns::ColumnId_Modification);
+        mRecordStateIndex = table->index(mIndex.row(), stateColumnIndex);
+        mOldRecordState = static_cast<CSMWorld::RecordBase::State>(table->data(mRecordStateIndex).toInt());
+    }
 }
 
 void CSMWorld::ModifyCommand::redo()
@@ -38,6 +47,10 @@ void CSMWorld::ModifyCommand::redo()
 void CSMWorld::ModifyCommand::undo()
 {
     mModel->setData (mIndex, mOld);
+    if (mHasRecordState)
+    {
+        mModel->setData(mRecordStateIndex, mOldRecordState);
+    }
 }
 
 
@@ -235,12 +248,12 @@ CSMWorld::DeleteNestedCommand::DeleteNestedCommand (IdTree& model,
                                                     int nestedRow,
                                                     int parentColumn,
                                                     QUndoCommand* parent) :
-    mId(id),
-    mModel(model),
-    mParentColumn(parentColumn),
     QUndoCommand(parent),
-    mNestedRow(nestedRow),
+    NestedTableStoring(model, id, parentColumn),
-    NestedTableStoring(model, id, parentColumn)
+    mModel(model),
+    mId(id),
+    mParentColumn(parentColumn),
+    mNestedRow(nestedRow)
 {
     std::string title =
         model.headerData(parentColumn, Qt::Horizontal, Qt::DisplayRole).toString().toUtf8().constData();
@@ -263,12 +276,12 @@ void CSMWorld::DeleteNestedCommand::undo()
 }
 
 CSMWorld::AddNestedCommand::AddNestedCommand(IdTree& model, const std::string& id, int nestedRow, int parentColumn, QUndoCommand* parent)
-    : mModel(model),
+    : QUndoCommand(parent),
+      NestedTableStoring(model, id, parentColumn),
+      mModel(model),
       mId(id),
       mNewRow(nestedRow),
-      mParentColumn(parentColumn),
+      mParentColumn(parentColumn)
-      QUndoCommand(parent),
-      NestedTableStoring(model, id, parentColumn)
 {
     std::string title =
         model.headerData(parentColumn, Qt::Horizontal, Qt::DisplayRole).toString().toUtf8().constData();

apps/opencs/model/world/commands.hpp

@@ -31,6 +31,10 @@ namespace CSMWorld
             QVariant mNew;
             QVariant mOld;
 
+            bool mHasRecordState;
+            QModelIndex mRecordStateIndex;
+            CSMWorld::RecordBase::State mOldRecordState;
+
         public:
 
             ModifyCommand (QAbstractItemModel& model, const QModelIndex& index, const QVariant& new_,

apps/opencs/model/world/data.cpp

@@ -242,6 +242,19 @@ CSMWorld::Data::Data (ToUTF8::FromType encoding, const ResourcesManager& resourc
     mTopicInfos.addAdapter (std::make_pair(&mTopicInfos.getColumn(index), new InfoListAdapter ()));
     mTopicInfos.getNestableColumn(index)->addColumn(
         new NestedChildColumn (Columns::ColumnId_ScriptText, ColumnBase::Display_ScriptLines));
+    // Special conditions
+    mTopicInfos.addColumn (new NestedParentColumn<Info> (Columns::ColumnId_InfoCondition));
+    index = mTopicInfos.getColumns()-1;
+    mTopicInfos.addAdapter (std::make_pair(&mTopicInfos.getColumn(index), new InfoConditionAdapter ()));
+    mTopicInfos.getNestableColumn(index)->addColumn(
+        new NestedChildColumn (Columns::ColumnId_InfoCondFunc, ColumnBase::Display_InfoCondFunc));
+    // FIXME: don't have dynamic value enum delegate, use Display_String for now
+    mTopicInfos.getNestableColumn(index)->addColumn(
+        new NestedChildColumn (Columns::ColumnId_InfoCondVar, ColumnBase::Display_String));
+    mTopicInfos.getNestableColumn(index)->addColumn(
+        new NestedChildColumn (Columns::ColumnId_InfoCondComp, ColumnBase::Display_InfoCondComp));
+    mTopicInfos.getNestableColumn(index)->addColumn(
+        new NestedChildColumn (Columns::ColumnId_Value, ColumnBase::Display_Var));
 
     mJournalInfos.addColumn (new StringIdColumn<Info> (true));
     mJournalInfos.addColumn (new RecordStateColumn<Info>);

apps/opencs/model/world/nestedcoladapterimp.cpp

@@ -528,4 +528,356 @@ namespace CSMWorld
     {
         return 1; // fixed at size 1
     }
+
+    // ESM::DialInfo::SelectStruct.mSelectRule
+    // 012345...
+    // ^^^ ^^
+    // ||| ||
+    // ||| |+------------- condition variable string
+    // ||| +-------------- comparison type, ['0'..'5']; e.g. !=, <, >=, etc
+    // ||+---------------- function index (encoded, where function == '1')
+    // |+----------------- function, ['1'..'C']; e.g. Global, Local, Not ID, etc
+    // +------------------ unknown
+    //
+    InfoConditionAdapter::InfoConditionAdapter () {}
+
+    void InfoConditionAdapter::addRow(Record<Info>& record, int position) const
+    {
+        Info info = record.get();
+
+        std::vector<ESM::DialInfo::SelectStruct>& conditions = info.mSelects;
+
+        // blank row
+        ESM::DialInfo::SelectStruct condStruct;
+        condStruct.mSelectRule = "00000";
+        condStruct.mValue = ESM::Variant();
+        condStruct.mValue.setType(ESM::VT_Int); // default to ints
+
+        conditions.insert(conditions.begin()+position, condStruct);
+
+        record.setModified (info);
+    }
+
+    void InfoConditionAdapter::removeRow(Record<Info>& record, int rowToRemove) const
+    {
+        Info info = record.get();
+
+        std::vector<ESM::DialInfo::SelectStruct>& conditions = info.mSelects;
+
+        if (rowToRemove < 0 || rowToRemove >= static_cast<int> (conditions.size()))
+            throw std::runtime_error ("index out of range");
+
+        conditions.erase(conditions.begin()+rowToRemove);
+
+        record.setModified (info);
+    }
+
+    void InfoConditionAdapter::setTable(Record<Info>& record,
+            const NestedTableWrapperBase& nestedTable) const
+    {
+        Info info = record.get();
+
+        info.mSelects =
+            static_cast<const NestedTableWrapper<std::vector<ESM::DialInfo::SelectStruct> >&>(nestedTable).mNestedTable;
+
+        record.setModified (info);
+    }
+
+    NestedTableWrapperBase* InfoConditionAdapter::table(const Record<Info>& record) const
+    {
+        // deleted by dtor of NestedTableStoring
+        return new NestedTableWrapper<std::vector<ESM::DialInfo::SelectStruct> >(record.get().mSelects);
+    }
+
+    // See the mappings in MWDialogue::SelectWrapper::getArgument
+    // from ESM::Attribute, ESM::Skill and MWMechanics::CreatureStats (for AI)
+    static std::map<const std::string, std::string> populateEncToInfoFunc()
+    {
+        std::map<const std::string, std::string> funcMap;
+        funcMap["00"] = "Rank Low";
+        funcMap["01"] = "Rank High";
+        funcMap["02"] = "Rank Requirement";
+        funcMap["03"] = "Reputation";
+        funcMap["04"] = "Health Percent";
+        funcMap["05"] = "PC Reputation";
+        funcMap["06"] = "PC Level";
+        funcMap["07"] = "PC Health Percent";
+        funcMap["08"] = "PC Magicka";
+        funcMap["09"] = "PC Fatigue";
+        funcMap["10"] = "PC Strength";
+        funcMap["11"] = "PC Block";
+        funcMap["12"] = "PC Armoror";
+        funcMap["13"] = "PC Medium Armor";
+        funcMap["14"] = "PC Heavy Armor";
+        funcMap["15"] = "PC Blunt Weapon";
+        funcMap["16"] = "PC Long Blade";
+        funcMap["17"] = "PC Axe";
+        funcMap["18"] = "PC Spear";
+        funcMap["19"] = "PC Athletics";
+        funcMap["20"] = "PC Enchant";
+        funcMap["21"] = "PC Destruction";
+        funcMap["22"] = "PC Alteration";
+        funcMap["23"] = "PC Illusion";
+        funcMap["24"] = "PC Conjuration";
+        funcMap["25"] = "PC Mysticism";
+        funcMap["26"] = "PC Restoration";
+        funcMap["27"] = "PC Alchemy";
+        funcMap["28"] = "PC Unarmored";
+        funcMap["29"] = "PC Security";
+        funcMap["30"] = "PC Sneak";
+        funcMap["31"] = "PC Acrobatics";
+        funcMap["32"] = "PC Light Armor";
+        funcMap["33"] = "PC Short Blade";
+        funcMap["34"] = "PC Marksman";
+        funcMap["35"] = "PC Merchantile";
+        funcMap["36"] = "PC Speechcraft";
+        funcMap["37"] = "PC Hand To Hand";
+        funcMap["38"] = "PC Sex";
+        funcMap["39"] = "PC Expelled";
+        funcMap["40"] = "PC Common Disease";
+        funcMap["41"] = "PC Blight Disease";
+        funcMap["42"] = "PC Clothing Modifier";
+        funcMap["43"] = "PC Crime Level";
+        funcMap["44"] = "Same Sex";
+        funcMap["45"] = "Same Race";
+        funcMap["46"] = "Same Faction";
+        funcMap["47"] = "Faction Rank Difference";
+        funcMap["48"] = "Detected";
+        funcMap["49"] = "Alarmed";
+        funcMap["50"] = "Choice";
+        funcMap["51"] = "PC Intelligence";
+        funcMap["52"] = "PC Willpower";
+        funcMap["53"] = "PC Agility";
+        funcMap["54"] = "PC Speed";
+        funcMap["55"] = "PC Endurance";
+        funcMap["56"] = "PC Personality";
+        funcMap["57"] = "PC Luck";
+        funcMap["58"] = "PC Corpus";
+        funcMap["59"] = "Weather";
+        funcMap["60"] = "PC Vampire";
+        funcMap["61"] = "Level";
+        funcMap["62"] = "Attacked";
+        funcMap["63"] = "Talked To PC";
+        funcMap["64"] = "PC Health";
+        funcMap["65"] = "Creature Target";
+        funcMap["66"] = "Friend Hit";
+        funcMap["67"] = "Fight";
+        funcMap["68"] = "Hello";
+        funcMap["69"] = "Alarm";
+        funcMap["70"] = "Flee";
+        funcMap["71"] = "Should Attack";
+        funcMap["72"] = "Werewolf";
+        funcMap["73"] = "PC Werewolf Kills";
+        return funcMap;
+    }
+    static const std::map<const std::string, std::string> sEncToInfoFunc = populateEncToInfoFunc();
+
+    QVariant InfoConditionAdapter::getData(const Record<Info>& record,
+            int subRowIndex, int subColIndex) const
+    {
+        Info info = record.get();
+
+        std::vector<ESM::DialInfo::SelectStruct>& conditions = info.mSelects;
+
+        if (subRowIndex < 0 || subRowIndex >= static_cast<int> (conditions.size()))
+            throw std::runtime_error ("index out of range");
+
+        switch (subColIndex)
+        {
+            case 0:
+            {
+                char condType = conditions[subRowIndex].mSelectRule[1];
+                switch (condType)
+                {
+                    case '0': return 0;  // blank space
+                    case '1': return 1;  // Function
+                    case '2': return 2;  // Global
+                    case '3': return 3;  // Local
+                    case '4': return 4;  // Journal
+                    case '5': return 5;  // Item
+                    case '6': return 6;  // Dead
+                    case '7': return 7;  // Not ID
+                    case '8': return 8;  // Not Factio
+                    case '9': return 9;  // Not Class
+                    case 'A': return 10; // Not Race
+                    case 'B': return 11; // Not Cell
+                    case 'C': return 12; // Not Local
+                    default: return QVariant(); // TODO: log an error?
+                }
+            }
+            case 1:
+            {
+                if (conditions[subRowIndex].mSelectRule[1] == '1')
+                {
+                    // throws an exception if the encoding is not found
+                    return sEncToInfoFunc.at(conditions[subRowIndex].mSelectRule.substr(2, 2)).c_str();
+                }
+                else
+                    return QString(conditions[subRowIndex].mSelectRule.substr(5).c_str());
+            }
+            case 2:
+            {
+                char compType = conditions[subRowIndex].mSelectRule[4];
+                switch (compType)
+                {
+                    case '0': return 3; // =
+                    case '1': return 0; // !=
+                    case '2': return 4; // >
+                    case '3': return 5; // >=
+                    case '4': return 1; // <
+                    case '5': return 2; // <=
+                    default: return QVariant(); // TODO: log an error?
+                }
+            }
+            case 3:
+            {
+                switch (conditions[subRowIndex].mValue.getType())
+                {
+                    case ESM::VT_String:
+                    {
+                        return QString::fromUtf8 (conditions[subRowIndex].mValue.getString().c_str());
+                    }
+                    case ESM::VT_Int:
+                    case ESM::VT_Short:
+                    case ESM::VT_Long:
+                    {
+                        return conditions[subRowIndex].mValue.getInteger();
+                    }
+                    case ESM::VT_Float:
+                    {
+                        return conditions[subRowIndex].mValue.getFloat();
+                    }
+                    default: return QVariant();
+                }
+            }
+            default: throw std::runtime_error("Info condition subcolumn index out of range");
+        }
+    }
+
+    void InfoConditionAdapter::setData(Record<Info>& record,
+            const QVariant& value, int subRowIndex, int subColIndex) const
+    {
+        Info info = record.get();
+
+        std::vector<ESM::DialInfo::SelectStruct>& conditions = info.mSelects;
+
+        if (subRowIndex < 0 || subRowIndex >= static_cast<int> (conditions.size()))
+            throw std::runtime_error ("index out of range");
+
+        switch (subColIndex)
+        {
+            case 0:
+            {
+                // See sInfoCondFunc in columns.cpp for the enum values
+                switch (value.toInt())
+                {
+                    // FIXME: when these change the values of the other columns need to change
+                    // correspondingly (and automatically)
+                    case 1:
+                    {
+                        conditions[subRowIndex].mSelectRule[1] = '1';             // Function
+                        // default to "Rank Low"
+                        conditions[subRowIndex].mSelectRule[2] = '0';
+                        conditions[subRowIndex].mSelectRule[3] = '0';
+                        break;
+                    }
+                    case 2:  conditions[subRowIndex].mSelectRule[1] = '2'; break; // Global
+                    case 3:  conditions[subRowIndex].mSelectRule[1] = '3'; break; // Local
+                    case 4:  conditions[subRowIndex].mSelectRule[1] = '4'; break; // Journal
+                    case 5:  conditions[subRowIndex].mSelectRule[1] = '5'; break; // Item
+                    case 6:  conditions[subRowIndex].mSelectRule[1] = '6'; break; // Dead
+                    case 7:  conditions[subRowIndex].mSelectRule[1] = '7'; break; // Not ID
+                    case 8:  conditions[subRowIndex].mSelectRule[1] = '8'; break; // Not Faction
+                    case 9:  conditions[subRowIndex].mSelectRule[1] = '9'; break; // Not Class
+                    case 10: conditions[subRowIndex].mSelectRule[1] = 'A'; break; // Not Race
+                    case 11: conditions[subRowIndex].mSelectRule[1] = 'B'; break; // Not Cell
+                    case 12: conditions[subRowIndex].mSelectRule[1] = 'C'; break; // Not Local
+                    default: return; // return without saving
+                }
+                break;
+            }
+            case 1:
+            {
+                if (conditions[subRowIndex].mSelectRule[1] == '1')
+                {
+                    std::map<const std::string, std::string>::const_iterator it = sEncToInfoFunc.begin();
+                    for (;it != sEncToInfoFunc.end(); ++it)
+                    {
+                        if (it->second == value.toString().toUtf8().constData())
+                        {
+                            std::string rule = conditions[subRowIndex].mSelectRule.substr(0, 2);
+                            rule.append(it->first);
+                            // leave old values for undo (NOTE: may not be vanilla's behaviour)
+                            rule.append(conditions[subRowIndex].mSelectRule.substr(4));
+                            conditions[subRowIndex].mSelectRule = rule;
+                            break;
+                        }
+                    }
+
+                    if (it == sEncToInfoFunc.end())
+                        return; // return without saving; TODO: maybe log an error here
+                }
+                else
+                {
+                    // FIXME: validate the string values before saving, based on the current function
+                    std::string rule = conditions[subRowIndex].mSelectRule.substr(0, 5);
+                    conditions[subRowIndex].mSelectRule = rule.append(value.toString().toUtf8().constData());
+                }
+                break;
+            }
+            case 2:
+            {
+                // See sInfoCondComp in columns.cpp for the enum values
+                switch (value.toInt())
+                {
+                    case 0: conditions[subRowIndex].mSelectRule[4] = '1'; break; // !=
+                    case 1: conditions[subRowIndex].mSelectRule[4] = '4'; break; // <
+                    case 2: conditions[subRowIndex].mSelectRule[4] = '5'; break; // <=
+                    case 3: conditions[subRowIndex].mSelectRule[4] = '0'; break; // =
+                    case 4: conditions[subRowIndex].mSelectRule[4] = '2'; break; // >
+                    case 5: conditions[subRowIndex].mSelectRule[4] = '3'; break; // >=
+                    default: return; // return without saving
+                }
+                break;
+            }
+            case 3:
+            {
+                switch (conditions[subRowIndex].mValue.getType())
+                {
+                    case ESM::VT_String:
+                    {
+                        conditions[subRowIndex].mValue.setString (value.toString().toUtf8().constData());
+                        break;
+                    }
+                    case ESM::VT_Int:
+                    case ESM::VT_Short:
+                    case ESM::VT_Long:
+                    {
+                        conditions[subRowIndex].mValue.setInteger (value.toInt());
+                        break;
+                    }
+                    case ESM::VT_Float:
+                    {
+                        conditions[subRowIndex].mValue.setFloat (value.toFloat());
+                        break;
+                    }
+                    default: break;
+                }
+                break;
+            }
+            default: throw std::runtime_error("Info condition subcolumn index out of range");
+        }
+
+        record.setModified (info);
+    }
+
+    int InfoConditionAdapter::getColumnsCount(const Record<Info>& record) const
+    {
+        return 4;
+    }
+
+    int InfoConditionAdapter::getRowsCount(const Record<Info>& record) const
+    {
+        return static_cast<int>(record.get().mSelects.size());
+    }
 }

apps/opencs/model/world/nestedcoladapterimp.hpp

@@ -311,7 +311,7 @@ namespace CSMWorld
                 case 0:
                 {
                     if (effect.mEffectID >=0 && effect.mEffectID < ESM::MagicEffect::Length)
-                        return effect.mRange;
+                        return effect.mEffectID;
                     else
                         throw std::runtime_error("Magic effects ID unexpected value");
                 }
@@ -412,6 +412,31 @@ namespace CSMWorld
 
         virtual int getRowsCount(const Record<Info>& record) const;
     };
+
+    class InfoConditionAdapter : public NestedColumnAdapter<Info>
+    {
+    public:
+        InfoConditionAdapter ();
+
+        virtual void addRow(Record<Info>& record, int position) const;
+
+        virtual void removeRow(Record<Info>& record, int rowToRemove) const;
+
+        virtual void setTable(Record<Info>& record,
+                const NestedTableWrapperBase& nestedTable) const;
+
+        virtual NestedTableWrapperBase* table(const Record<Info>& record) const;
+
+        virtual QVariant getData(const Record<Info>& record,
+                int subRowIndex, int subColIndex) const;
+
+        virtual void setData(Record<Info>& record,
+                const QVariant& value, int subRowIndex, int subColIndex) const;
+
+        virtual int getColumnsCount(const Record<Info>& record) const;
+
+        virtual int getRowsCount(const Record<Info>& record) const;
+    };
 }
 
 #endif // CSM_WOLRD_NESTEDCOLADAPTERIMP_H

apps/opencs/model/world/refidadapterimp.cpp

@@ -13,7 +13,7 @@ CSMWorld::PotionColumns::PotionColumns (const InventoryColumns& columns)
 CSMWorld::PotionRefIdAdapter::PotionRefIdAdapter (const PotionColumns& columns,
     const RefIdColumn *autoCalc)
 : InventoryRefIdAdapter<ESM::Potion> (UniversalId::Type_Potion, columns),
-  mAutoCalc (autoCalc), mColumns(columns)
+  mColumns(columns), mAutoCalc (autoCalc)
 {}
 
 QVariant CSMWorld::PotionRefIdAdapter::getData (const RefIdColumn *column, const RefIdData& data,

apps/opencs/model/world/refiddata.cpp

@@ -176,7 +176,6 @@ void CSMWorld::RefIdData::erase (const LocalIndex& index, int count)
 {
     std::map<UniversalId::Type, RefIdDataContainerBase *>::iterator iter =
         mRecordContainers.find (index.second);
-
     if (iter==mRecordContainers.end())
         throw std::logic_error ("invalid local index type");
 
@@ -189,6 +188,20 @@ void CSMWorld::RefIdData::erase (const LocalIndex& index, int count)
             mIndex.erase (result);
     }
 
+    // Adjust the local indexes to avoid gaps between them after removal of records
+    int recordIndex = index.first + count;
+    int recordCount = iter->second->getSize();
+    while (recordIndex < recordCount)
+    {
+        std::map<std::string, LocalIndex>::iterator recordIndexFound =
+            mIndex.find(Misc::StringUtils::lowerCase(iter->second->getId(recordIndex)));
+        if (recordIndexFound != mIndex.end())
+        {
+            recordIndexFound->second.first -= count;
+        }
+        ++recordIndex;
+    }
+
     iter->second->erase (index.first, count);
 }
 

apps/opencs/view/doc/filedialog.cpp

@@ -18,7 +18,7 @@
 #include "adjusterwidget.hpp"
 
 CSVDoc::FileDialog::FileDialog(QWidget *parent) :
-    QDialog(parent), mSelector (0), mFileWidget (0), mAdjusterWidget (0), mDialogBuilt(false), mAction(ContentAction_Undefined)
+    QDialog(parent), mSelector (0), mAction(ContentAction_Undefined), mFileWidget (0), mAdjusterWidget (0), mDialogBuilt(false)
 {
     ui.setupUi (this);
     resize(400, 400);

apps/opencs/view/doc/sizehint.cpp

@@ -0,0 +1,17 @@
+#include "sizehint.hpp"
+
+CSVDoc::SizeHintWidget::SizeHintWidget(QWidget *parent) : QWidget(parent)
+{}
+
+CSVDoc::SizeHintWidget::~SizeHintWidget()
+{}
+
+QSize CSVDoc::SizeHintWidget::sizeHint() const
+{
+    return mSize;
+}
+
+void CSVDoc::SizeHintWidget::setSizeHint(const QSize &size)
+{
+    mSize = size;
+}

apps/opencs/view/doc/sizehint.hpp

@@ -0,0 +1,22 @@
+#ifndef CSV_DOC_SIZEHINT_H
+#define CSV_DOC_SIZEHINT_H
+
+#include <QWidget>
+#include <QSize>
+
+namespace CSVDoc
+{
+    class SizeHintWidget : public QWidget
+    {
+            QSize mSize;
+
+        public:
+            SizeHintWidget(QWidget *parent = 0);
+            ~SizeHintWidget();
+
+            virtual QSize sizeHint() const;
+            void setSizeHint(const QSize &size);
+    };
+}
+
+#endif // CSV_DOC_SIZEHINT_H

apps/opencs/view/doc/subview.cpp

@@ -2,6 +2,24 @@
 
 #include "view.hpp"
 
+#include <QShortcut>
+#include <QEvent>
+#include <QKeyEvent>
+
+bool CSVDoc::SubView::event (QEvent *event)
+{
+    if (event->type()==QEvent::ShortcutOverride)
+    {
+        QKeyEvent *keyEvent = static_cast<QKeyEvent *> (event);
+
+        if (keyEvent->key()==Qt::Key_W && keyEvent->modifiers()==(Qt::ShiftModifier | Qt::ControlModifier))
+            emit closeRequest();
+            return true;
+    }
+    
+    return QDockWidget::event (event);
+}
+
 CSVDoc::SubView::SubView (const CSMWorld::UniversalId& id)
  : mUniversalId (id)
 {

apps/opencs/view/doc/subview.hpp

@@ -34,6 +34,8 @@ namespace CSVDoc
 
             void setUniversalId(const CSMWorld::UniversalId& id);
 
+            bool event (QEvent *event);
+
         public:
 
             SubView (const CSMWorld::UniversalId& id);

apps/opencs/view/doc/view.cpp

@@ -9,6 +9,10 @@
 #include <QDockWidget>
 #include <QtGui/QApplication>
 #include <QDesktopWidget>
+#include <QScrollArea>
+#include <QHBoxLayout>
+#include <QDesktopWidget>
+#include <QScrollBar>
 
 #include "../../model/doc/document.hpp"
 #include "../../model/settings/usersettings.hpp"
@@ -16,6 +20,7 @@
 #include "../../model/world/idtable.hpp"
 
 #include "../world/subviews.hpp"
+#include "../world/tablesubview.hpp"
 
 #include "../tools/subviews.hpp"
 
@@ -334,8 +339,15 @@ void CSVDoc::View::updateTitle()
 void CSVDoc::View::updateSubViewIndicies(SubView *view)
 {
     if(view && mSubViews.contains(view))
+    {
         mSubViews.removeOne(view);
 
+        // adjust (reduce) the scroll area (even floating), except when it is "Scrollbar Only"
+        CSMSettings::UserSettings &settings = CSMSettings::UserSettings::instance();
+        if(settings.settingValue ("window/mainwindow-scrollbar") == "Grow then Scroll")
+            updateScrollbar();
+    }
+
     CSMSettings::UserSettings &userSettings = CSMSettings::UserSettings::instance();
 
     bool hideTitle = userSettings.setting ("window/hide-subview", QString ("false"))=="true" &&
@@ -381,7 +393,7 @@ void CSVDoc::View::updateActions()
 
 CSVDoc::View::View (ViewManager& viewManager, CSMDoc::Document *document, int totalViews)
     : mViewManager (viewManager), mDocument (document), mViewIndex (totalViews-1),
-      mViewTotal (totalViews)
+      mViewTotal (totalViews), mScroll(0), mScrollbarOnly(false)
 {
     int width = CSMSettings::UserSettings::instance().settingValue
                                     ("window/default-width").toInt();
@@ -400,7 +412,18 @@ CSVDoc::View::View (ViewManager& viewManager, CSMDoc::Document *document, int to
 
     mSubViewWindow.setDockOptions (QMainWindow::AllowNestedDocks);
 
-    setCentralWidget (&mSubViewWindow);
+    CSMSettings::UserSettings &settings = CSMSettings::UserSettings::instance();
+    if(settings.settingValue ("window/mainwindow-scrollbar") == "Grow Only")
+    {
+        setCentralWidget (&mSubViewWindow);
+    }
+    else
+    {
+        mScroll = new QScrollArea(this);
+        mScroll->setWidgetResizable(true);
+        mScroll->setWidget(&mSubViewWindow);
+        setCentralWidget(mScroll);
+    }
 
     mOperations = new Operations;
     addDockWidget (Qt::BottomDockWidgetArea, mOperations);
@@ -527,6 +550,54 @@ void CSVDoc::View::addSubView (const CSMWorld::UniversalId& id, const std::strin
 
     view->setStatusBar (mShowStatusBar->isChecked());
 
+    // Work out how to deal with additional subviews
+    //
+    // Policy for "Grow then Scroll":
+    //
+    // - Increase the horizontal width of the mainwindow until it becomes greater than or equal
+    //   to the screen (monitor) width.
+    // - Move the mainwindow position sideways if necessary to fit within the screen.
+    // - Any more additions increases the size of the mSubViewWindow (horizontal scrollbar
+    //   should become visible)
+    // - Move the scroll bar to the newly added subview
+    //
+    CSMSettings::UserSettings &settings = CSMSettings::UserSettings::instance();
+    QString mainwinScroll = settings.settingValue ("window/mainwindow-scrollbar");
+    mScrollbarOnly = mainwinScroll.isEmpty() || mainwinScroll == "Scrollbar Only";
+
+    QDesktopWidget *dw = QApplication::desktop();
+    QRect rect;
+    if(settings.settingValue ("window/grow-limit") == "true")
+        rect = dw->screenGeometry(this);
+    else
+        rect = dw->screenGeometry(dw->screen(dw->screenNumber(this)));
+
+    if (!mScrollbarOnly && mScroll && mSubViews.size() > 1)
+    {
+        int newWidth = width()+minWidth;
+        int frameWidth = frameGeometry().width() - width();
+        if (newWidth+frameWidth <= rect.width())
+        {
+            resize(newWidth, height());
+            // WARNING: below code assumes that new subviews are added to the right
+            if (x() > rect.width()-(newWidth+frameWidth))
+                move(rect.width()-(newWidth+frameWidth), y()); // shift left to stay within the screen
+        }
+        else
+        {
+            // full width
+            resize(rect.width()-frameWidth, height());
+            mSubViewWindow.setMinimumWidth(mSubViewWindow.width()+minWidth);
+            move(0, y());
+        }
+
+        // Make the new subview visible, setFocus() or raise() don't seem to work
+        // On Ubuntu the scrollbar does not go right to the end, even if using
+        // mScroll->horizontalScrollBar()->setValue(mScroll->horizontalScrollBar()->maximum());
+        if (mSubViewWindow.width() > rect.width())
+            mScroll->horizontalScrollBar()->setValue(mSubViewWindow.width());
+    }
+
     mSubViewWindow.addDockWidget (Qt::TopDockWidgetArea, view);
 
     updateSubViewIndicies();
@@ -774,6 +845,48 @@ void CSVDoc::View::updateUserSetting (const QString &name, const QStringList &li
     {
         subView->updateUserSetting (name, list);
     }
+
+    if (name=="window/mainwindow-scrollbar")
+    {
+        if(list.at(0) != "Grow Only")
+        {
+            if (mScroll)
+            {
+                if (list.at(0).isEmpty() || list.at(0) == "Scrollbar Only")
+                {
+                    mScrollbarOnly = true;
+                    mSubViewWindow.setMinimumWidth(0);
+                }
+                else
+                {
+                    if(!mScrollbarOnly)
+                        return;
+
+                    mScrollbarOnly = false;
+                    updateScrollbar();
+                }
+            }
+            else
+            {
+                mScroll = new QScrollArea(this);
+                mScroll->setWidgetResizable(true);
+                mScroll->setWidget(&mSubViewWindow);
+                setCentralWidget(mScroll);
+            }
+        }
+        else
+        {
+            if (mScroll)
+            {
+                mScroll->takeWidget();
+                setCentralWidget (&mSubViewWindow);
+                mScroll->deleteLater();
+                mScroll = 0;
+            }
+            else
+                return;
+        }
+    }
 }
 
 void CSVDoc::View::toggleShowStatusBar (bool show)
@@ -811,7 +924,33 @@ void CSVDoc::View::closeRequest (SubView *subView)
 
     if (mSubViews.size()>1 || mViewTotal<=1 ||
         userSettings.setting ("window/hide-subview", QString ("false"))!="true")
+    {
         subView->deleteLater();
+        mSubViews.removeOne (subView);
+    }
     else if (mViewManager.closeRequest (this))
         mViewManager.removeDocAndView (mDocument);
 }
+
+void CSVDoc::View::updateScrollbar()
+{
+    QRect rect;
+    QWidget *topLevel = QApplication::topLevelAt(pos());
+    if (topLevel)
+        rect = topLevel->rect();
+    else
+        rect = this->rect();
+
+    int newWidth = 0;
+    for (int i = 0; i < mSubViews.size(); ++i)
+    {
+        newWidth += mSubViews[i]->width();
+    }
+
+    int frameWidth = frameGeometry().width() - width();
+
+    if ((newWidth+frameWidth) >= rect.width())
+        mSubViewWindow.setMinimumWidth(newWidth);
+    else
+        mSubViewWindow.setMinimumWidth(0);
+}

apps/opencs/view/doc/view.hpp

@@ -10,6 +10,7 @@
 
 class QAction;
 class QDockWidget;
+class QScrollArea;
 
 namespace CSMDoc
 {
@@ -47,6 +48,8 @@ namespace CSVDoc
             SubViewFactoryManager mSubViewFactory;
             QMainWindow mSubViewWindow;
             GlobalDebugProfileMenu *mGlobalDebugProfileMenu;
+            QScrollArea *mScroll;
+            bool mScrollbarOnly;
 
 
             // not implemented
@@ -87,6 +90,8 @@ namespace CSVDoc
             /// User preference function
             void resizeViewHeight (int height);
 
+            void updateScrollbar();
+
         public:
 
             View (ViewManager& viewManager, CSMDoc::Document *document, int totalViews);

apps/opencs/view/doc/viewmanager.cpp

@@ -90,7 +90,9 @@ CSVDoc::ViewManager::ViewManager (CSMDoc::DocumentManager& documentManager)
         { CSMWorld::ColumnBase::Display_EffectId, CSMWorld::Columns::ColumnId_EffectId, false },
         { CSMWorld::ColumnBase::Display_PartRefType, CSMWorld::Columns::ColumnId_PartRefType, false },
         { CSMWorld::ColumnBase::Display_AiPackageType, CSMWorld::Columns::ColumnId_AiPackageType, false },
-        { CSMWorld::ColumnBase::Display_YesNo, CSMWorld::Columns::ColumnId_AiWanderRepeat, false }
+        { CSMWorld::ColumnBase::Display_YesNo, CSMWorld::Columns::ColumnId_AiWanderRepeat, false },
+        { CSMWorld::ColumnBase::Display_InfoCondFunc, CSMWorld::Columns::ColumnId_InfoCondFunc, false },
+        { CSMWorld::ColumnBase::Display_InfoCondComp, CSMWorld::Columns::ColumnId_InfoCondComp, false }
     };
 
     for (std::size_t i=0; i<sizeof (sMapping)/sizeof (Mapping); ++i)

apps/opencs/view/render/worldspacewidget.cpp

@@ -19,7 +19,7 @@
 #include "editmode.hpp"
 
 CSVRender::WorldspaceWidget::WorldspaceWidget (CSMDoc::Document& document, QWidget* parent)
-: SceneWidget (document.getData().getResourceSystem()->getSceneManager(), parent), mDocument(document), mSceneElements(0), mRun(0),
+: SceneWidget (document.getData().getResourceSystem()->getSceneManager(), parent), mSceneElements(0), mRun(0), mDocument(document),
   mInteractionMask (0)
 {
     setAcceptDrops(true);

apps/opencs/view/settings/booleanview.cpp

@@ -12,7 +12,7 @@
 
 CSVSettings::BooleanView::BooleanView (CSMSettings::Setting *setting,
                                        Page *parent)
-    : mType(setting->type()), View (setting, parent)
+    : View (setting, parent), mType(setting->type())
 {
     foreach (const QString &value, setting->declaredValues())
     {

apps/opencs/view/settings/dialog.cpp

@@ -23,7 +23,7 @@
 #include <QStandardItem>
 
 CSVSettings::Dialog::Dialog(QMainWindow *parent)
-    : mStackedWidget (0), mDebugMode (false), SettingWindow (parent)
+    : SettingWindow (parent), mStackedWidget (0), mDebugMode (false)
 {
     setWindowTitle(QString::fromUtf8 ("User Settings"));
 

apps/opencs/view/settings/frame.cpp

@@ -7,8 +7,8 @@ const QString CSVSettings::Frame::sInvisibleBoxStyle =
 
 CSVSettings::Frame::Frame (bool isVisible, const QString &title,
                                                                QWidget *parent)
-    : mIsHorizontal (true), mLayout (new SettingLayout()),
+    : QGroupBox (title, parent), mIsHorizontal (true),
-    QGroupBox (title, parent)
+    mLayout (new SettingLayout())
 {
     setFlat (true);
     mVisibleBoxStyle = styleSheet();

apps/opencs/view/settings/listview.cpp

@@ -7,7 +7,7 @@
 
 CSVSettings::ListView::ListView(CSMSettings::Setting *setting,
                                 Page *parent)
-    : mComboBox (0), mAbstractItemView (0), View(setting, parent)
+    : View(setting, parent), mAbstractItemView (0), mComboBox (0)
 {
     QWidget *widget =
                     buildWidget(setting->isMultiLine(), setting->widgetWidth());

apps/opencs/view/settings/page.cpp

@@ -19,7 +19,7 @@ QMap <CSVSettings::ViewType, CSVSettings::IViewFactory *>
 
 CSVSettings::Page::Page (const QString &pageName, QList <CSMSettings::Setting *> settingList,
     SettingWindow *parent, const QString& label)
-: mParent(parent), mIsEditorPage (false), Frame(false, "", parent), mLabel (label)
+: Frame(false, "", parent), mParent(parent), mIsEditorPage (false), mLabel (label)
 {
     setObjectName (pageName);
 

apps/opencs/view/settings/spinbox.cpp

@@ -3,7 +3,7 @@
 #include <QLineEdit>
 
 CSVSettings::SpinBox::SpinBox(QWidget *parent)
-    : mValueList(QStringList()), QSpinBox(parent)
+    : QSpinBox(parent), mValueList(QStringList())
 {
     setRange (0, 0);
 }

apps/opencs/view/settings/view.cpp

@@ -12,12 +12,12 @@
 CSVSettings::View::View(CSMSettings::Setting *setting,
                         Page *parent)
 
-    : mDataModel(0), mParentPage (parent),
+    : Frame(true, setting->getLabel(), parent),
+      mParentPage (parent), mDataModel(0),
       mHasFixedValues (!setting->declaredValues().isEmpty()),
       mIsMultiValue (setting->isMultiValue()),
       mViewKey (setting->page() + '/' + setting->name()),
-      mSerializable (setting->serializable()),
+      mSerializable (setting->serializable())
-      Frame(true, setting->getLabel(), parent)
 {
     if (!setting->getToolTip().isEmpty())
         setToolTip (setting->getToolTip());

apps/opencs/view/tools/searchbox.cpp

@@ -153,6 +153,11 @@ void CSVTools::SearchBox::setEditLock (bool locked)
     mReplace.setEnabled (!locked);
 }
 
+void CSVTools::SearchBox::focus()
+{
+    mInput.currentWidget()->setFocus();
+}
+
 void CSVTools::SearchBox::modeSelected (int index)
 {
     switch (index)
@@ -172,6 +177,8 @@ void CSVTools::SearchBox::modeSelected (int index)
             break;
     }
 
+    mInput.currentWidget()->setFocus();
+    
     updateSearchButton();
 }
 

apps/opencs/view/tools/searchbox.hpp

@@ -49,6 +49,8 @@ namespace CSVTools
 
             void setEditLock (bool locked);
 
+            void focus();
+
         private slots:
 
             void modeSelected (int index);

apps/opencs/view/tools/searchsubview.cpp

@@ -60,6 +60,12 @@ void CSVTools::SearchSubView::replace (bool selection)
     }
 }
 
+void CSVTools::SearchSubView::showEvent (QShowEvent *event)
+{
+    CSVDoc::SubView::showEvent (event);
+    mSearchBox.focus();    
+}
+
 CSVTools::SearchSubView::SearchSubView (const CSMWorld::UniversalId& id, CSMDoc::Document& document)
 : CSVDoc::SubView (id), mDocument (document), mLocked (false)
 {
@@ -83,7 +89,7 @@ CSVTools::SearchSubView::SearchSubView (const CSMWorld::UniversalId& id, CSMDoc:
         SIGNAL (focusId (const CSMWorld::UniversalId&, const std::string&)));
 
     connect (mTable, SIGNAL (replaceRequest()), this, SLOT (replaceRequest()));
-        
+       
     connect (&document, SIGNAL (stateChanged (int, CSMDoc::Document *)),
         this, SLOT (stateChanged (int, CSMDoc::Document *)));
 

apps/opencs/view/tools/searchsubview.hpp

@@ -32,6 +32,10 @@ namespace CSVTools
         private:
 
             void replace (bool selection);
+
+        protected:
+
+            void showEvent (QShowEvent *event);
             
         public:
 

apps/opencs/view/world/dialoguesubview.cpp

@@ -356,15 +356,15 @@ CSVWorld::EditWidget::~EditWidget()
 CSVWorld::EditWidget::EditWidget(QWidget *parent,
         int row, CSMWorld::IdTable* table, CSMWorld::CommandDispatcher& commandDispatcher,
         CSMDoc::Document& document, bool createAndDelete) :
-mDispatcher(this, table, commandDispatcher, document),
-mNestedTableDispatcher(NULL),
 QScrollArea(parent),
 mWidgetMapper(NULL),
 mNestedTableMapper(NULL),
+mDispatcher(this, table, commandDispatcher, document),
+mNestedTableDispatcher(NULL),
 mMainWidget(NULL),
+mTable(table),
 mCommandDispatcher (commandDispatcher),
-mDocument (document),
+mDocument (document)
-mTable(table)
 {
     remake (row);
 
@@ -571,8 +571,8 @@ CSVWorld::DialogueSubView::DialogueSubView (const CSMWorld::UniversalId& id, CSM
     SubView (id),
     mEditWidget(0),
     mMainLayout(NULL),
-    mUndoStack(document.getUndoStack()),
     mTable(dynamic_cast<CSMWorld::IdTable*>(document.getData().getTableModel(id))),
+    mUndoStack(document.getUndoStack()),
     mLocked(false),
     mDocument(document),
     mCommandDispatcher (document, CSMWorld::UniversalId::getParentType (id.getType()))

apps/opencs/view/world/dragrecordtable.cpp

@@ -17,8 +17,8 @@ void CSVWorld::DragRecordTable::startDragFromTable (const CSVWorld::DragRecordTa
 }
 
 CSVWorld::DragRecordTable::DragRecordTable (CSMDoc::Document& document, QWidget* parent) :
-mDocument(document),
 QTableView(parent),
+mDocument(document),
 mEditLock(false)
 {}
 

apps/opencs/view/world/genericcreator.cpp

@@ -129,9 +129,9 @@ void CSVWorld::GenericCreator::addScope (const QString& name, CSMWorld::Scope sc
 
 CSVWorld::GenericCreator::GenericCreator (CSMWorld::Data& data, QUndoStack& undoStack,
     const CSMWorld::UniversalId& id, bool relaxedIdRules)
-: mData (data), mUndoStack (undoStack), mListId (id), mLocked (false), mCloneMode (false),
+: mData (data), mUndoStack (undoStack), mListId (id), mLocked (false),
   mClonedType (CSMWorld::UniversalId::Type_None), mScopes (CSMWorld::Scope_Content), mScope (0),
-  mScopeLabel (0)
+  mScopeLabel (0), mCloneMode (false)
 {
     mLayout = new QHBoxLayout;
     mLayout->setContentsMargins (0, 0, 0, 0);

apps/opencs/view/world/scenesubview.cpp

@@ -27,7 +27,7 @@
 #include "creator.hpp"
 
 CSVWorld::SceneSubView::SceneSubView (const CSMWorld::UniversalId& id, CSMDoc::Document& document)
-: SubView (id), mLayout(new QHBoxLayout), mDocument(document), mScene(NULL), mToolbar(NULL)
+: SubView (id), mScene(NULL), mLayout(new QHBoxLayout), mDocument(document), mToolbar(NULL)
 {
     QVBoxLayout *layout = new QVBoxLayout;
 

apps/opencs/view/world/scriptedit.cpp

@@ -25,17 +25,31 @@ CSVWorld::ScriptEdit::ChangeLock::~ChangeLock()
     --mEdit.mChangeLocked;
 }
 
+bool CSVWorld::ScriptEdit::event (QEvent *event)
+{
+    // ignore undo and redo shortcuts
+    if (event->type()==QEvent::ShortcutOverride)
+    {
+        QKeyEvent *keyEvent = static_cast<QKeyEvent *> (event);
+        
+        if (keyEvent->matches (QKeySequence::Undo) || keyEvent->matches (QKeySequence::Redo))
+            return true;
+    }
+    
+    return QPlainTextEdit::event (event);
+}
 
 CSVWorld::ScriptEdit::ScriptEdit (const CSMDoc::Document& document, ScriptHighlighter::Mode mode,
     QWidget* parent)
     : QPlainTextEdit (parent),
-    mDocument (document),
-    mWhiteListQoutes("^[a-z|_]{1}[a-z|0-9|_]{0,}$", Qt::CaseInsensitive),
     mChangeLocked (0),
-    mLineNumberArea(0),
     mShowLineNum(false),
+    mLineNumberArea(0),
     mDefaultFont(font()),
-    mMonoFont(QFont("Monospace"))
+    mMonoFont(QFont("Monospace")),
+    mDocument (document),
+    mWhiteListQoutes("^[a-z|_]{1}[a-z|0-9|_]{0,}$", Qt::CaseInsensitive)
+
 {
 //    setAcceptRichText (false);
     setLineWrapMode (QPlainTextEdit::NoWrap);

apps/opencs/view/world/scriptedit.hpp

@@ -53,6 +53,10 @@ namespace CSVWorld
             QFont mDefaultFont;
             QFont mMonoFont;
 
+        protected:
+
+            bool event (QEvent *event);
+            
         public:
 
             ScriptEdit (const CSMDoc::Document& document, ScriptHighlighter::Mode mode,

apps/opencs/view/world/table.cpp

@@ -21,6 +21,7 @@
 #include "../../model/world/tablemimedata.hpp"
 #include "../../model/world/tablemimedata.hpp"
 #include "../../model/world/commanddispatcher.hpp"
+#include "../../model/settings/usersettings.hpp"
 
 #include "recordstatusdelegate.hpp"
 #include "util.hpp"
@@ -252,9 +253,27 @@ void CSVWorld::Table::mouseDoubleClickEvent (QMouseEvent *event)
 
 CSVWorld::Table::Table (const CSMWorld::UniversalId& id,
     bool createAndDelete, bool sorting, CSMDoc::Document& document)
-: mCreateAction (0), mCloneAction(0), mRecordStatusDisplay (0),
+: DragRecordTable(document), mCreateAction (0),
-  DragRecordTable(document)
+  mCloneAction(0),mRecordStatusDisplay (0)
 {
+    CSMSettings::UserSettings &settings = CSMSettings::UserSettings::instance();
+    QString jumpSetting = settings.settingValue ("table-input/jump-to-added");
+    if (jumpSetting.isEmpty() || jumpSetting == "Jump and Select") // default
+    {
+        mJumpToAddedRecord = true;
+        mUnselectAfterJump = false;
+    }
+    else if(jumpSetting == "Jump Only")
+    {
+        mJumpToAddedRecord = true;
+        mUnselectAfterJump = true;
+    }
+    else
+    {
+        mJumpToAddedRecord = false;
+        mUnselectAfterJump = false;
+    }
+
     mModel = &dynamic_cast<CSMWorld::IdTableBase&> (*mDocument.getData().getTableModel (id));
 
     mProxyModel = new CSMWorld::IdTableProxyModel (this);
@@ -345,9 +364,12 @@ CSVWorld::Table::Table (const CSMWorld::UniversalId& id,
     connect (mExtendedRevertAction, SIGNAL (triggered()), mDispatcher, SLOT (executeExtendedRevert()));
     addAction (mExtendedRevertAction);
 
-    connect (mProxyModel, SIGNAL (rowsInserted (const QModelIndex&, int, int)),
+    connect (mProxyModel, SIGNAL (rowsRemoved (const QModelIndex&, int, int)),
         this, SLOT (tableSizeUpdate()));
 
+    connect (mProxyModel, SIGNAL (rowsInserted (const QModelIndex&, int, int)),
+        this, SLOT (rowsInsertedEvent(const QModelIndex&, int, int)));
+
     /// \note This signal could instead be connected to a slot that filters out changes not affecting
     /// the records status column (for permanence reasons)
     connect (mProxyModel, SIGNAL (dataChanged (const QModelIndex&, const QModelIndex&)),
@@ -517,9 +539,27 @@ void CSVWorld::Table::previewRecord()
     }
 }
 
-void CSVWorld::Table::updateUserSetting
+void CSVWorld::Table::updateUserSetting (const QString &name, const QStringList &list)
-                                (const QString &name, const QStringList &list)
 {
+    if (name=="table-input/jump-to-added")
+    {
+        if(list.isEmpty() || list.at(0) == "Jump and Select") // default
+        {
+            mJumpToAddedRecord = true;
+            mUnselectAfterJump = false;
+        }
+        else if(list.at(0) == "Jump Only")
+        {
+            mJumpToAddedRecord = true;
+            mUnselectAfterJump = true;
+        }
+        else // No Jump
+        {
+            mJumpToAddedRecord = false;
+            mUnselectAfterJump = false;
+        }
+    }
+
     if (name=="records/type-format" || name=="records/status-format")
     {
         int columns = mModel->columnCount();
@@ -700,3 +740,14 @@ std::vector< CSMWorld::UniversalId > CSVWorld::Table::getDraggedRecords() const
     return idToDrag;
 }
 
+void CSVWorld::Table::rowsInsertedEvent(const QModelIndex& parent, int start, int end)
+{
+    tableSizeUpdate();
+    if(mJumpToAddedRecord)
+    {
+        selectRow(end);
+
+        if(mUnselectAfterJump)
+            clearSelection();
+    }
+}

apps/opencs/view/world/table.hpp

@@ -67,6 +67,8 @@ namespace CSVWorld
             CSMWorld::CommandDispatcher *mDispatcher;
             CSMWorld::UniversalId mEditCellId;
             std::map<Qt::KeyboardModifiers, DoubleClickAction> mDoubleClickActions;
+            bool mJumpToAddedRecord;
+            bool mUnselectAfterJump;
 
         private:
 
@@ -139,6 +141,8 @@ namespace CSVWorld
             void recordFilterChanged (boost::shared_ptr<CSMFilter::Node> filter);
 
             void updateUserSetting (const QString &name, const QStringList &list);
+
+            void rowsInsertedEvent(const QModelIndex& parent, int start, int end);
     };
 }
 

apps/opencs/view/world/tablesubview.cpp

@@ -3,10 +3,14 @@
 
 #include <QVBoxLayout>
 #include <QEvent>
+#include <QHeaderView>
+#include <QApplication>
+#include <QDesktopWidget>
 
 #include "../../model/doc/document.hpp"
 #include "../../model/world/tablemimedata.hpp"
 
+#include "../doc/sizehint.hpp"
 #include "../filter/filterbox.hpp"
 #include "table.hpp"
 #include "tablebottombox.hpp"
@@ -30,11 +34,18 @@ CSVWorld::TableSubView::TableSubView (const CSMWorld::UniversalId& id, CSMDoc::D
 
     layout->insertWidget (0, mFilterBox);
 
-    QWidget *widget = new QWidget;
+    CSVDoc::SizeHintWidget *widget = new CSVDoc::SizeHintWidget;
 
     widget->setLayout (layout);
 
     setWidget (widget);
+    // prefer height of the screen and full width of the table
+    const QRect rect = QApplication::desktop()->screenGeometry(this);
+    int frameHeight = 40; // set a reasonable default
+    QWidget *topLevel = QApplication::topLevelAt(pos());
+    if (topLevel)
+        frameHeight = topLevel->frameGeometry().height() - topLevel->height();
+    widget->setSizeHint(QSize(mTable->horizontalHeader()->length(), rect.height()-frameHeight));
 
     connect (mTable, SIGNAL (editRequest (const CSMWorld::UniversalId&, const std::string&)),
         this, SLOT (editRequest (const CSMWorld::UniversalId&, const std::string&)));

apps/openmw/mwbase/environment.cpp

@@ -17,8 +17,8 @@ MWBase::Environment *MWBase::Environment::sThis = 0;
 
 MWBase::Environment::Environment()
 : mWorld (0), mSoundManager (0), mScriptManager (0), mWindowManager (0),
-  mMechanicsManager (0),  mDialogueManager (0), mJournal (0), mInputManager (0), mFrameDuration (0),
+  mMechanicsManager (0),  mDialogueManager (0), mJournal (0), mInputManager (0), mStateManager (0),
-  mStateManager (0)
+  mFrameDuration (0)
 {
     assert (!sThis);
     sThis = this;

apps/openmw/mwbase/world.hpp

@@ -277,8 +277,8 @@ namespace MWBase
             virtual MWWorld::Ptr moveObject (const MWWorld::Ptr& ptr, float x, float y, float z) = 0;
             ///< @return an updated Ptr in case the Ptr's cell changes
 
-            virtual void
+            virtual MWWorld::Ptr moveObject(const MWWorld::Ptr &ptr, MWWorld::CellStore* newCell, float x, float y, float z) = 0;
-            moveObject(const MWWorld::Ptr &ptr, MWWorld::CellStore* newCell, float x, float y, float z) = 0;
+            ///< @return an updated Ptr
 
             virtual void scaleObject (const MWWorld::Ptr& ptr, float scale) = 0;
 

apps/openmw/mwclass/creature.cpp

@@ -251,7 +251,7 @@ namespace MWClass
 
         float hitchance = MWMechanics::getHitChance(ptr, victim, ref->mBase->mData.mCombat);
 
-        if(Misc::Rng::rollProbability() >= hitchance/100.0f)
+        if(Misc::Rng::roll0to99() >= hitchance)
         {
             victim.getClass().onHit(victim, 0.0f, false, MWWorld::Ptr(), ptr, false);
             MWMechanics::reduceWeaponCondition(0.f, false, weapon, ptr);

apps/openmw/mwclass/npc.cpp

@@ -513,7 +513,7 @@ namespace MWClass
 
         float hitchance = MWMechanics::getHitChance(ptr, victim, ptr.getClass().getSkill(ptr, weapskill));
 
-        if (Misc::Rng::rollProbability() >= hitchance / 100.0f)
+        if (Misc::Rng::roll0to99() >= hitchance)
         {
             othercls.onHit(victim, 0.0f, false, weapon, ptr, false);
             MWMechanics::reduceWeaponCondition(0.f, false, weapon, ptr);

apps/openmw/mwdialogue/dialoguemanagerimp.cpp

@@ -48,12 +48,15 @@
 namespace MWDialogue
 {
     DialogueManager::DialogueManager (const Compiler::Extensions& extensions, bool scriptVerbose, Translation::Storage& translationDataStorage) :
-      mCompilerContext (MWScript::CompilerContext::Type_Dialogue),
+      mTranslationDataStorage(translationDataStorage)
-        mErrorStream(std::cout.rdbuf()),mErrorHandler(mErrorStream)
+      , mCompilerContext (MWScript::CompilerContext::Type_Dialogue)
-      , mTemporaryDispositionChange(0.f)
+      , mErrorStream(std::cout.rdbuf())
-      , mPermanentDispositionChange(0.f), mScriptVerbose (scriptVerbose)
+      , mErrorHandler(mErrorStream)
-      , mTranslationDataStorage(translationDataStorage)
       , mTalkedTo(false)
+      , mTemporaryDispositionChange(0.f)
+      , mPermanentDispositionChange(0.f)
+      , mScriptVerbose (scriptVerbose)
+
     {
         mChoice = -1;
         mIsInChoice = false;
@@ -485,6 +488,12 @@ namespace MWDialogue
 
                     executeScript (info->mResultScript);
                 }
+                else
+                {
+                    mChoice = -1;
+                    mIsInChoice = false;
+                    MWBase::Environment::get().getWindowManager()->getDialogueWindow()->clearChoices();
+                }
             }
         }
 

apps/openmw/mwgui/alchemywindow.cpp

@@ -26,10 +26,10 @@ namespace MWGui
 {
     AlchemyWindow::AlchemyWindow()
         : WindowBase("openmw_alchemy_window.layout")
-        , mApparatus (4)
-        , mIngredients (4)
         , mSortModel(NULL)
         , mAlchemy(new MWMechanics::Alchemy())
+        , mApparatus (4)
+        , mIngredients (4)
     {
         getWidget(mCreateButton, "CreateButton");
         getWidget(mCancelButton, "CancelButton");

apps/openmw/mwgui/bookpage.cpp

@@ -228,8 +228,8 @@ struct TypesetBookImpl::Typesetter : BookTypesetter
     Typesetter (size_t width, size_t height) :
         mPageWidth (width), mPageHeight(height),
         mSection (NULL), mLine (NULL), mRun (NULL),
-        mCurrentAlignment (AlignLeft),
+        mCurrentContent (NULL),
-        mCurrentContent (NULL)
+        mCurrentAlignment (AlignLeft)
     {
         mBook = boost::make_shared <Book> ();
     }
@@ -697,10 +697,10 @@ namespace
 
         GlyphStream (MyGUI::IFont* font, float left, float top, float Z,
                       MyGUI::Vertex* vertices, RenderXform const & renderXform) :
-            mZ(Z), mOrigin (left, top),
+            mZ(Z),
-            mFont (font), mVertices (vertices),
+            mC(0), mFont (font), mOrigin (left, top),
-            mRenderXform (renderXform),
+            mVertices (vertices),
-            mC(0)
+            mRenderXform (renderXform)
         {
             mVertexColourType = MyGUI::RenderManager::getInstance().getVertexFormat();
         }
@@ -801,10 +801,10 @@ protected:
 
         TextFormat (MyGUI::IFont* id, PageDisplay * display) :
             mFont (id),
+            mCountVertex (0),
             mTexture (NULL),
             mRenderItem (NULL),
-            mDisplay (display),
+            mDisplay (display)
-            mCountVertex (0)
         {
         }
 

apps/openmw/mwgui/bookwindow.cpp

@@ -18,9 +18,9 @@ namespace MWGui
 
     BookWindow::BookWindow ()
         : WindowBase("openmw_book.layout")
+        , mCurrentPage(0)
         , mTakeButtonShow(true)
         , mTakeButtonAllowed(true)
-        , mCurrentPage(0)
     {
         getWidget(mCloseButton, "CloseButton");
         mCloseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &BookWindow::onCloseButtonClicked);

apps/openmw/mwgui/companionwindow.cpp

@@ -37,11 +37,11 @@ namespace MWGui
 
 CompanionWindow::CompanionWindow(DragAndDrop *dragAndDrop, MessageBoxManager* manager)
     : WindowBase("openmw_companion_window.layout")
+    , mSortModel(NULL)
+    , mModel(NULL)
+    , mSelectedItem(-1)
     , mDragAndDrop(dragAndDrop)
     , mMessageBoxManager(manager)
-    , mSelectedItem(-1)
-    , mModel(NULL)
-    , mSortModel(NULL)
 {
     getWidget(mCloseButton, "CloseButton");
     getWidget(mProfitLabel, "ProfitLabel");

apps/openmw/mwgui/container.cpp

@@ -33,10 +33,10 @@ namespace MWGui
     ContainerWindow::ContainerWindow(DragAndDrop* dragAndDrop)
         : WindowBase("openmw_container_window.layout")
         , mDragAndDrop(dragAndDrop)
-        , mSelectedItem(-1)
-        , mModel(NULL)
-        , mSortModel(NULL)
         , mPickpocketDetected(false)
+        , mSortModel(NULL)
+        , mModel(NULL)
+        , mSelectedItem(-1)
     {
         getWidget(mDisposeCorpseButton, "DisposeCorpseButton");
         getWidget(mTakeButton, "TakeButton");

apps/openmw/mwgui/dialogue.cpp

@@ -248,10 +248,10 @@ namespace MWGui
 
     DialogueWindow::DialogueWindow()
         : WindowBase("openmw_dialogue_window.layout")
-        , mPersuasionDialog()
-        , mEnabled(false)
         , mServices(0)
+        , mEnabled(false)
         , mGoodbye(false)
+        , mPersuasionDialog()
     {
         // Centre dialog
         center();

apps/openmw/mwgui/draganddrop.cpp

@@ -20,12 +20,12 @@ namespace MWGui
 
 
 DragAndDrop::DragAndDrop()
-    : mDraggedWidget(NULL)
+    : mIsOnDragAndDrop(false)
-    , mDraggedCount(0)
+    , mDraggedWidget(NULL)
     , mSourceModel(NULL)
     , mSourceView(NULL)
     , mSourceSortModel(NULL)
-    , mIsOnDragAndDrop(false)
+    , mDraggedCount(0)
 {
 }
 

apps/openmw/mwgui/inventorywindow.cpp

@@ -54,17 +54,17 @@ namespace MWGui
 
     InventoryWindow::InventoryWindow(DragAndDrop* dragAndDrop, osgViewer::Viewer* viewer, Resource::ResourceSystem* resourceSystem)
         : WindowPinnableBase("openmw_inventory_window.layout")
-        , mTrading(false)
-        , mLastXSize(0)
-        , mLastYSize(0)
         , mViewer(viewer)
         , mResourceSystem(resourceSystem)
-        , mPreview(new MWRender::InventoryPreview(viewer, resourceSystem, MWBase::Environment::get().getWorld()->getPlayerPtr()))
         , mDragAndDrop(dragAndDrop)
+        , mSelectedItem(-1)
         , mSortModel(NULL)
         , mTradeModel(NULL)
-        , mSelectedItem(-1)
         , mGuiMode(GM_Inventory)
+        , mLastXSize(0)
+        , mLastYSize(0)
+        , mPreview(new MWRender::InventoryPreview(viewer, resourceSystem, MWBase::Environment::get().getWorld()->getPlayerPtr()))
+        , mTrading(false)
     {
         mPreviewTexture.reset(new osgMyGUI::OSGTexture(mPreview->getTexture()));
         mPreview->rebuild();
@@ -598,6 +598,8 @@ namespace MWGui
         MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
         MWBase::Environment::get().getWorld()->breakInvisibility(player);
 
+        MWBase::Environment::get().getMechanicsManager()->itemTaken(player, object, MWWorld::Ptr(), count);
+
         // add to player inventory
         // can't use ActionTake here because we need an MWWorld::Ptr to the newly inserted object
         MWWorld::Ptr newObject = *player.getClass().getContainerStore (player).add (object, object.getRefData().getCount(), player);
@@ -616,8 +618,6 @@ namespace MWGui
             throw std::runtime_error("Added item not found");
         mDragAndDrop->startDrag(i, mSortModel, mTradeModel, mItemView, count);
 
-        MWBase::Environment::get().getMechanicsManager()->itemTaken(player, newObject, MWWorld::Ptr(), count);
-
         MWBase::Environment::get().getWindowManager()->updateSpellWindow();
     }
 

apps/openmw/mwgui/itemmodel.cpp

@@ -14,10 +14,10 @@ namespace MWGui
 {
 
     ItemStack::ItemStack(const MWWorld::Ptr &base, ItemModel *creator, size_t count)
-        : mCreator(creator)
+        : mType(Type_Normal)
-        , mCount(count)
         , mFlags(0)
-        , mType(Type_Normal)
+        , mCreator(creator)
+        , mCount(count)
         , mBase(base)
     {
         if (base.getClass().getEnchantment(base) != "")
@@ -59,10 +59,10 @@ namespace MWGui
     }
 
     ItemStack::ItemStack()
-        : mCreator(NULL)
+        : mType(Type_Normal)
-        , mCount(0)
         , mFlags(0)
-        , mType(Type_Normal)
+        , mCreator(NULL)
+        , mCount(0)
     {
     }
 

apps/openmw/mwgui/jailscreen.cpp

@@ -19,9 +19,9 @@ namespace MWGui
 {
     JailScreen::JailScreen()
         : WindowBase("openmw_jail_screen.layout"),
-          mTimeAdvancer(0.01f),
           mDays(1),
-          mFadeTimeRemaining(0)
+          mFadeTimeRemaining(0),
+          mTimeAdvancer(0.01f)
     {
         getWidget(mProgressBar, "ProgressBar");
 

apps/openmw/mwgui/journalbooks.cpp

@@ -68,8 +68,8 @@ namespace
         AddJournalEntry (MWGui::BookTypesetter::Ptr typesetter, MWGui::BookTypesetter::Style* body_style,
                             MWGui::BookTypesetter::Style* header_style, bool add_header) :
             AddEntry (typesetter, body_style),
-            mHeaderStyle (header_style),
+            mAddHeader (add_header),
-            mAddHeader (add_header)
+            mHeaderStyle (header_style)
         {
         }
 
@@ -94,7 +94,7 @@ namespace
 
         AddTopicEntry (MWGui::BookTypesetter::Ptr typesetter, MWGui::BookTypesetter::Style* body_style,
                         MWGui::BookTypesetter::Style* header_style, intptr_t contentId) :
-            AddEntry (typesetter, body_style), mHeaderStyle (header_style), mContentId (contentId)
+            AddEntry (typesetter, body_style), mContentId (contentId), mHeaderStyle (header_style)
         {
         }
 

apps/openmw/mwgui/journalviewmodel.cpp

@@ -92,7 +92,7 @@ struct JournalViewModelImpl : JournalViewModel
         JournalViewModelImpl const *    mModel;
 
         BaseEntry (JournalViewModelImpl const * model, iterator_t itr) :
-            mModel (model), itr (itr), loaded (false)
+            itr (itr), mModel (model), loaded (false)
         {}
 
         virtual ~BaseEntry () {}

apps/openmw/mwgui/mapwindow.cpp

@@ -146,16 +146,16 @@ namespace MWGui
         : mCurX(0)
         , mCurY(0)
         , mInterior(false)
-        , mFogOfWar(true)
         , mLocalMap(NULL)
+        , mCompass(NULL)
         , mPrefix()
         , mChanged(true)
+        , mFogOfWar(true)
+        , mMapWidgetSize(0)
+        , mCustomMarkers(markers)
+        , mMarkerUpdateTimer(0.0f)
         , mLastDirectionX(0.0f)
         , mLastDirectionY(0.0f)
-        , mCompass(NULL)
-        , mMarkerUpdateTimer(0.0f)
-        , mCustomMarkers(markers)
-        , mMapWidgetSize(0)
     {
         mCustomMarkers.eventMarkersChanged += MyGUI::newDelegate(this, &LocalMapBase::updateCustomMarkers);
     }
@@ -304,17 +304,17 @@ namespace MWGui
             MarkerUserData markerPos;
             MyGUI::IntPoint widgetPos = getMarkerPosition(marker.mWorldX, marker.mWorldY, markerPos);
 
-            MyGUI::IntCoord widgetCoord(widgetPos.left - 4,
+            MyGUI::IntCoord widgetCoord(widgetPos.left - 8,
-                                        widgetPos.top - 4,
+                                        widgetPos.top - 8,
-                                        8, 8);
+                                        16, 16);
-            MarkerWidget* markerWidget = mLocalMap->createWidget<MarkerWidget>("MarkerButton",
+            MarkerWidget* markerWidget = mLocalMap->createWidget<MarkerWidget>("CustomMarkerButton",
                 widgetCoord, MyGUI::Align::Default);
             markerWidget->setDepth(Local_MarkerAboveFogLayer);
             markerWidget->setUserString("ToolTipType", "Layout");
             markerWidget->setUserString("ToolTipLayout", "TextToolTipOneLine");
             markerWidget->setUserString("Caption_TextOneLine", MyGUI::TextIterator::toTagsString(marker.mNote));
-            markerWidget->setNormalColour(MyGUI::Colour(1.0f, 0.3f, 0.3f));
+            markerWidget->setNormalColour(MyGUI::Colour(0.6f, 0.6f, 0.6f));
-            markerWidget->setHoverColour(MyGUI::Colour(1.0f, 0.5f, 0.5f));
+            markerWidget->setHoverColour(MyGUI::Colour(1.0f, 1.0f, 1.0f));
             markerWidget->setUserData(marker);
             markerWidget->setNeedMouseFocus(true);
             customMarkerCreated(markerWidget);
@@ -473,21 +473,17 @@ namespace MWGui
             return;
 
         std::string markerTexture;
-        MyGUI::Colour markerColour;
         if (type == MWBase::World::Detect_Creature)
         {
-            markerTexture = "textures\\menu_map_dcreature.dds";
+            markerTexture = "textures\\detect_animal_icon.dds";
-            markerColour = MyGUI::Colour(1,0,0,1);
         }
         if (type == MWBase::World::Detect_Key)
         {
-            markerTexture = "textures\\menu_map_dkey.dds";
+            markerTexture = "textures\\detect_key_icon.dds";
-            markerColour = MyGUI::Colour(0,1,0,1);
         }
         if (type == MWBase::World::Detect_Enchantment)
         {
-            markerTexture = "textures\\menu_map_dmagic.dds";
+            markerTexture = "textures\\detect_enchantment_icon.dds";
-            markerColour = MyGUI::Colour(0,0,1,1);
         }
 
         int counter = 0;
@@ -504,7 +500,7 @@ namespace MWGui
                 widgetCoord, MyGUI::Align::Default);
             markerWidget->setDepth(Local_MarkerAboveFogLayer);
             markerWidget->setImageTexture(markerTexture);
-            markerWidget->setColour(markerColour);
+            markerWidget->setImageCoord(MyGUI::IntCoord(0,0,8,8));
             markerWidget->setNeedMouseFocus(false);
             mMagicMarkerWidgets.push_back(markerWidget);
         }
@@ -559,17 +555,17 @@ namespace MWGui
 
     MapWindow::MapWindow(CustomMarkerCollection &customMarkers, DragAndDrop* drag, const std::string& cacheDir)
         : WindowPinnableBase("openmw_map_window.layout")
-        , NoDrop(drag, mMainWidget)
         , LocalMapBase(customMarkers)
-        , mGlobalMapTexture(NULL)
+        , NoDrop(drag, mMainWidget)
-        , mGlobal(false)
         , mGlobalMap(0)
-        //, mGlobalMapRender(0)
+        , mGlobalMapTexture(NULL)
-        , mEditNoteDialog()
-        , mEventBoxGlobal(NULL)
-        , mEventBoxLocal(NULL)
         , mGlobalMapImage(NULL)
         , mGlobalMapOverlay(NULL)
+        , mGlobal(false)
+        , mEventBoxGlobal(NULL)
+        , mEventBoxLocal(NULL)
+        , mGlobalMapRender(0)
+        , mEditNoteDialog()
     {
         static bool registered = false;
         if (!registered)

apps/openmw/mwgui/messagebox.cpp

@@ -161,10 +161,10 @@ namespace MWGui
 
     MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message)
       : Layout("openmw_messagebox.layout")
-      , mMessageBoxManager(parMessageBoxManager)
-      , mMessage(message)
       , mCurrentTime(0)
       , mMaxTime(0)
+      , mMessageBoxManager(parMessageBoxManager)
+      , mMessage(message)
     {
         // defines
         mBottomPadding = 48;
@@ -195,8 +195,8 @@ namespace MWGui
     InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message, const std::vector<std::string>& buttons)
         : WindowModal("openmw_interactive_messagebox.layout")
       , mMessageBoxManager(parMessageBoxManager)
+      , mTextButtonPadding(0)
       , mButtonPressed(-1)
-        , mTextButtonPadding(0)
     {
         WindowModal::open();
 

apps/openmw/mwgui/pickpocketitemmodel.cpp

@@ -20,7 +20,7 @@ namespace MWGui
         {
             for (size_t i = 0; i<mSourceModel->getItemCount(); ++i)
             {
-                if (chance <= Misc::Rng::roll0to99())
+                if (Misc::Rng::roll0to99() > chance)
                     mHiddenItems.push_back(mSourceModel->getItem(i));
             }
         }

apps/openmw/mwgui/sortfilteritemmodel.cpp

@@ -70,9 +70,9 @@ namespace MWGui
 
     SortFilterItemModel::SortFilterItemModel(ItemModel *sourceModel)
         : mCategory(Category_All)
+        , mFilter(0)
         , mShowEquipped(true)
         , mSortByType(true)
-        , mFilter(0)
     {
         mSourceModel = sourceModel;
     }

apps/openmw/mwgui/spellbuyingwindow.cpp

@@ -23,8 +23,8 @@ namespace MWGui
 
     SpellBuyingWindow::SpellBuyingWindow() :
         WindowBase("openmw_spell_buying_window.layout")
-        , mCurrentY(0)
         , mLastPos(0)
+        , mCurrentY(0)
     {
         setCoord(0, 0, 450, 300);
 
@@ -127,13 +127,7 @@ namespace MWGui
     bool SpellBuyingWindow::playerHasSpell(const std::string &id)
     {
         MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
-        MWMechanics::Spells& playerSpells = player.getClass().getCreatureStats (player).getSpells();
+        return player.getClass().getCreatureStats(player).getSpells().hasSpell(id);
-        for (MWMechanics::Spells::TIterator it = playerSpells.begin(); it != playerSpells.end(); ++it)
-        {
-            if (Misc::StringUtils::ciEqual(id, it->first))
-                return true;
-        }
-        return false;
     }
 
     void SpellBuyingWindow::onSpellButtonClick(MyGUI::Widget* _sender)

apps/openmw/mwgui/spellcreationdialog.cpp

@@ -483,15 +483,15 @@ namespace MWGui
 
 
     EffectEditorBase::EffectEditorBase(Type type)
-        : mAddEffectDialog()
+        : mAvailableEffectsList(NULL)
-        , mAvailableEffectsList(NULL)
         , mUsedEffectsView(NULL)
+        , mAddEffectDialog()
         , mSelectAttributeDialog(NULL)
         , mSelectSkillDialog(NULL)
         , mSelectedEffect(0)
         , mSelectedKnownEffectId(0)
-        , mType(type)
         , mConstantEffect(false)
+        , mType(type)
     {
         mAddEffectDialog.eventEffectAdded += MyGUI::newDelegate(this, &EffectEditorBase::onEffectAdded);
         mAddEffectDialog.eventEffectModified += MyGUI::newDelegate(this, &EffectEditorBase::onEffectModified);

apps/openmw/mwgui/tooltips.cpp

@@ -30,15 +30,15 @@ namespace MWGui
 
     ToolTips::ToolTips() :
         Layout("openmw_tooltips.layout")
-        , mFullHelp(false)
-        , mEnabled(true)
         , mFocusToolTipX(0.0)
         , mFocusToolTipY(0.0)
+        , mHorizontalScrollIndex(0)
         , mDelay(0.0)
         , mRemainingDelay(0.0)
         , mLastMouseX(0)
         , mLastMouseY(0)
-        , mHorizontalScrollIndex(0)
+        , mEnabled(true)
+        , mFullHelp(false)
     {
         getWidget(mDynamicToolTipBox, "DynamicToolTipBox");
 

apps/openmw/mwgui/waitdialog.cpp

@@ -50,13 +50,13 @@ namespace MWGui
 
     WaitDialog::WaitDialog()
         : WindowBase("openmw_wait_dialog.layout")
-        , mProgressBar()
         , mTimeAdvancer(0.05f)
         , mSleeping(false)
         , mHours(1)
         , mManualHours(1)
         , mFadeTimeRemaining(0)
         , mInterruptAt(-1)
+        , mProgressBar()
     {
         getWidget(mDateTimeText, "DateTimeText");
         getWidget(mRestText, "RestText");
@@ -155,8 +155,9 @@ namespace MWGui
                 if (!region->mSleepList.empty())
                 {
                     // figure out if player will be woken while sleeping
+                    int x = Misc::Rng::rollDice(hoursToWait);
                     float fSleepRandMod = world->getStore().get<ESM::GameSetting>().find("fSleepRandMod")->getFloat();
-                    if (Misc::Rng::rollProbability() > fSleepRandMod)
+                    if (x < fSleepRandMod * hoursToWait)
                     {
                         float fSleepRestMod = world->getStore().get<ESM::GameSetting>().find("fSleepRestMod")->getFloat();
                         mInterruptAt = hoursToWait - int(fSleepRestMod * hoursToWait);

apps/openmw/mwgui/windowbase.cpp

@@ -75,7 +75,7 @@ void WindowModal::close()
 }
 
 NoDrop::NoDrop(DragAndDrop *drag, MyGUI::Widget *widget)
-    : mDrag(drag), mWidget(widget), mTransparent(false)
+    : mWidget(widget), mDrag(drag), mTransparent(false)
 {
     if (!mWidget)
         throw std::runtime_error("NoDrop needs a non-NULL widget!");

apps/openmw/mwmechanics/aiavoiddoor.cpp

@@ -13,7 +13,7 @@
 #include "steering.hpp"
 
 MWMechanics::AiAvoidDoor::AiAvoidDoor(const MWWorld::Ptr& doorPtr)
-: AiPackage(), mDoorPtr(doorPtr), mDuration(1), mAdjAngle(0)
+: AiPackage(), mDuration(1), mDoorPtr(doorPtr), mAdjAngle(0)
 {
 
 }

apps/openmw/mwmechanics/aicombat.cpp

@@ -111,17 +111,17 @@ namespace MWMechanics
         mTimerAttack(0),
         mTimerReact(0),
         mTimerCombatMove(0),
+        mReadyToAttack(false),
         mAttack(false),
         mFollowTarget(false),
         mCombatMove(false),
-        mReadyToAttack(false),
+        mLastTargetPos(0,0,0),
-        mForceNoShortcut(false),
         mCell(NULL),
         mCurrentAction(),
         mActionCooldown(0),
         mStrength(),
         mMinMaxAttackDurationInitialised(false),
-        mLastTargetPos(0,0,0),
+        mForceNoShortcut(false),
         mLastActorPos(0,0,0),
         mMovement(){}    
     };

apps/openmw/mwmechanics/aiescort.cpp

@@ -49,12 +49,11 @@ namespace MWMechanics
     }
 
     AiEscort::AiEscort(const ESM::AiSequence::AiEscort *escort)
-        : mActorId(escort->mTargetId), mX(escort->mData.mX), mY(escort->mData.mY), mZ(escort->mData.mZ)
+        : mActorId(escort->mTargetId), mCellId(escort->mCellId), mX(escort->mData.mX), mY(escort->mData.mY), mZ(escort->mData.mZ)
+        , mMaxDist(450)
+        , mRemainingDuration(escort->mRemainingDuration)
         , mCellX(std::numeric_limits<int>::max())
         , mCellY(std::numeric_limits<int>::max())
-        , mCellId(escort->mCellId)
-        , mRemainingDuration(escort->mRemainingDuration)
-        , mMaxDist(450)
     {
     }
 

apps/openmw/mwmechanics/aifollow.cpp

@@ -32,27 +32,27 @@ int AiFollow::mFollowIndexCounter = 0;
 
 AiFollow::AiFollow(const std::string &actorId,float duration, float x, float y, float z)
 : mAlwaysFollow(false), mCommanded(false), mRemainingDuration(duration), mX(x), mY(y), mZ(z)
-, mActorRefId(actorId), mCellId(""), mActorId(-1), mFollowIndex(mFollowIndexCounter++), mActive(false)
+, mActorRefId(actorId), mActorId(-1), mCellId(""), mActive(false), mFollowIndex(mFollowIndexCounter++)
 {
 }
 AiFollow::AiFollow(const std::string &actorId,const std::string &cellId,float duration, float x, float y, float z)
 : mAlwaysFollow(false), mCommanded(false), mRemainingDuration(duration), mX(x), mY(y), mZ(z)
-, mActorRefId(actorId), mCellId(cellId), mActorId(-1), mFollowIndex(mFollowIndexCounter++), mActive(false)
+, mActorRefId(actorId), mActorId(-1), mCellId(cellId), mActive(false), mFollowIndex(mFollowIndexCounter++)
 {
 }
 
 AiFollow::AiFollow(const std::string &actorId, bool commanded)
 : mAlwaysFollow(true), mCommanded(commanded), mRemainingDuration(0), mX(0), mY(0), mZ(0)
-, mActorRefId(actorId), mCellId(""), mActorId(-1), mFollowIndex(mFollowIndexCounter++), mActive(false)
+, mActorRefId(actorId), mActorId(-1), mCellId(""), mActive(false), mFollowIndex(mFollowIndexCounter++)
 {
 
 }
 
 AiFollow::AiFollow(const ESM::AiSequence::AiFollow *follow)
-    : mAlwaysFollow(follow->mAlwaysFollow), mRemainingDuration(follow->mRemainingDuration)
+    : mAlwaysFollow(follow->mAlwaysFollow), mCommanded(follow->mCommanded), mRemainingDuration(follow->mRemainingDuration)
     , mX(follow->mData.mX), mY(follow->mData.mY), mZ(follow->mData.mZ)
-    , mActorRefId(follow->mTargetId), mActorId(-1), mCellId(follow->mCellId)
+    , mActorRefId(follow->mTargetId), mActorId(-1)
-    , mCommanded(follow->mCommanded), mFollowIndex(mFollowIndexCounter++), mActive(follow->mActive)
+    , mCellId(follow->mCellId), mActive(follow->mActive), mFollowIndex(mFollowIndexCounter++)
 {
 
 }

apps/openmw/mwmechanics/aiwander.cpp

@@ -786,10 +786,10 @@ namespace MWMechanics
     AiWander::AiWander (const ESM::AiSequence::AiWander* wander)
         : mDistance(wander->mData.mDistance)
         , mDuration(wander->mData.mDuration)
-        , mStartTime(MWWorld::TimeStamp(wander->mStartTime))
         , mTimeOfDay(wander->mData.mTimeOfDay)
         , mRepeat(wander->mData.mShouldRepeat != 0)
         , mStoredInitialActorPosition(wander->mStoredInitialActorPosition)
+        , mStartTime(MWWorld::TimeStamp(wander->mStartTime))
     {
         if (mStoredInitialActorPosition)
             mInitialActorPosition = wander->mInitialActorPosition;

apps/openmw/mwmechanics/character.cpp

@@ -641,8 +641,8 @@ CharacterController::CharacterController(const MWWorld::Ptr &ptr, MWRender::Anim
     , mJumpState(JumpState_None)
     , mWeaponType(WeapType_None)
     , mSkipAnim(false)
-    , mSecondsOfRunning(0)
     , mSecondsOfSwimming(0)
+    , mSecondsOfRunning(0)
     , mTurnAnimationThreshold(0)
 {
     if(!mAnimation)

apps/openmw/mwmechanics/combat.cpp

@@ -187,7 +187,7 @@ namespace MWMechanics
         int skillValue = attacker.getClass().getSkill(attacker,
                                            weapon.getClass().getEquipmentSkill(weapon));
 
-        if (Misc::Rng::rollProbability() >= getHitChance(attacker, victim, skillValue) / 100.0f)
+        if (Misc::Rng::roll0to99() >= getHitChance(attacker, victim, skillValue))
         {
             victim.getClass().onHit(victim, 0.0f, false, projectile, attacker, false);
             MWMechanics::reduceWeaponCondition(0.f, false, weapon, attacker);

apps/openmw/mwmechanics/creaturestats.cpp

@@ -15,16 +15,12 @@ namespace MWMechanics
     int CreatureStats::sActorId = 0;
 
     CreatureStats::CreatureStats()
-        : mLevel (0), mDead (false), mDied (false), mMurdered(false), mFriendlyHits (0),
+        : mDrawState (DrawState_Nothing), mDead (false), mDied (false), mMurdered(false), mFriendlyHits (0),
-          mTalkedTo (false), mAlarmed (false),
+          mTalkedTo (false), mAlarmed (false), mAttacked (false), mAttackingOrSpell(false),
-          mAttacked (false),
+          mKnockdown(false), mKnockdownOneFrame(false), mKnockdownOverOneFrame(false),
-          mAttackingOrSpell(false),
+          mHitRecovery(false), mBlock(false), mMovementFlags(0), mAttackStrength(0.f),
-          mIsWerewolf(false),
+          mFallHeight(0), mRecalcMagicka(false), mLastRestock(0,0), mGoldPool(0), mActorId(-1),
-          mFallHeight(0), mRecalcMagicka(false), mKnockdown(false), mKnockdownOneFrame(false),
+          mDeathAnimation(0), mIsWerewolf(false), mLevel (0)
-          mKnockdownOverOneFrame(false), mHitRecovery(false), mBlock(false),
-          mMovementFlags(0), mDrawState (DrawState_Nothing), mAttackStrength(0.f),
-          mLastRestock(0,0), mGoldPool(0), mActorId(-1),
-          mDeathAnimation(0)
     {
         for (int i=0; i<4; ++i)
             mAiSettings[i] = 0;

apps/openmw/mwmechanics/mechanicsmanagerimp.cpp

@@ -737,7 +737,7 @@ namespace MWMechanics
         float x = 0;
         float y = 0;
 
-        float roll = Misc::Rng::rollClosedProbability() * 100;
+        int roll = Misc::Rng::roll0to99();
 
         if (type == PT_Admire)
         {

apps/openmw/mwmechanics/npcstats.cpp

@@ -25,12 +25,12 @@
 #include "../mwbase/soundmanager.hpp"
 
 MWMechanics::NpcStats::NpcStats()
-    : mBounty (0)
+    : mDisposition (0)
-, mLevelProgress(0)
-, mDisposition(0)
 , mReputation(0)
 , mCrimeId(-1)
+, mBounty(0)
 , mWerewolfKills (0)
+, mLevelProgress(0)
 , mTimeToStartDrowning(20.0)
 {
     mSkillIncreases.resize (ESM::Attribute::Length, 0);

apps/openmw/mwmechanics/obstacle.cpp

@@ -63,10 +63,10 @@ namespace MWMechanics
     ObstacleCheck::ObstacleCheck():
         mPrevX(0) // to see if the moved since last time
       , mPrevY(0)
-      , mDistSameSpot(-1) // avoid calculating it each time
       , mWalkState(State_Norm)
       , mStuckDuration(0)
       , mEvadeDuration(0)
+      , mDistSameSpot(-1) // avoid calculating it each time
     {
     }
 

apps/openmw/mwmechanics/pathgrid.cpp

@@ -51,12 +51,12 @@ namespace MWMechanics
 {
     PathgridGraph::PathgridGraph()
         : mCell(NULL)
-        , mIsGraphConstructed(false)
         , mPathgrid(NULL)
+        , mIsExterior(0)
         , mGraph(0)
+        , mIsGraphConstructed(false)
         , mSCCId(0)
         , mSCCIndex(0)
-        , mIsExterior(0)
     {
     }
 

apps/openmw/mwmechanics/spells.cpp

@@ -143,6 +143,20 @@ namespace MWMechanics
         return mSelectedSpell;
     }
 
+    bool Spells::isSpellActive(const std::string &id) const
+    {
+        TContainer::const_iterator found = mSpells.find(id);
+        if (found != mSpells.end())
+        {
+            const ESM::Spell *spell =
+                MWBase::Environment::get().getWorld()->getStore().get<ESM::Spell>().find (id);
+
+            return (spell->mData.mType==ESM::Spell::ST_Ability || spell->mData.mType==ESM::Spell::ST_Blight ||
+                spell->mData.mType==ESM::Spell::ST_Disease || spell->mData.mType==ESM::Spell::ST_Curse);
+        }
+        return false;
+    }
+
     bool Spells::hasCommonDisease() const
     {
         for (TIterator iter = mSpells.begin(); iter!=mSpells.end(); ++iter)

apps/openmw/mwmechanics/spells.hpp

@@ -98,6 +98,9 @@ namespace MWMechanics
             const std::string getSelectedSpell() const;
             ///< May return an empty string.
 
+            bool isSpellActive(const std::string& id) const;
+            ///< Are we under the effects of the given spell ID?
+
             bool hasCommonDisease() const;
 
             bool hasBlightDisease() const;

apps/openmw/mwrender/globalmap.cpp

@@ -19,10 +19,11 @@ namespace MWRender
 {
 
     GlobalMap::GlobalMap()
-        : mMinX(0), mMaxX(0)
+        : mWidth(0)
-        , mMinY(0), mMaxY(0)
-        , mWidth(0)
         , mHeight(0)
+        , mMinX(0), mMaxX(0)
+        , mMinY(0), mMaxY(0)
+
     {
         mCellSize = Settings::Manager::getInt("global map cell size", "Map");
     }

apps/openmw/mwrender/water.cpp

@@ -186,10 +186,10 @@ void PlaneReflection::setVisibilityMask (int flags)
 
 Water::Water (Ogre::Camera *camera, RenderingManager* rend, const MWWorld::Fallback* fallback) :
     mCamera (camera), mSceneMgr (camera->getSceneManager()),
-    mIsUnderwater(false), mVisibilityFlags(0),
+    mIsUnderwater(false), mActive(1),
-    mActive(1), mToggled(1),
+    mToggled(1), mWaterTimer(0.f),
     mRendering(rend),
-    mWaterTimer(0.f),
+    mVisibilityFlags(0),
     mReflection(NULL),
     mRefraction(NULL),
     mSimulation(NULL),