Config "salvation" :-)

src/libHeaven/App/Mode.cpp

@@ -40,6 +40,7 @@ namespace Heaven
         if( !tryLoadConfig() )
         {
             d->mRoot = d->mOriginalState;
+            d->mRoot->setReadOnly(true);
         }
     }
 

src/libHeaven/App/Mode.hpp

@@ -29,7 +29,7 @@ class QDomElement;
 namespace Heaven
 {
 
-    class WindowStateRoot;
+    class WindowStateRoot;  //<- Internal class, we don't want to include it, thus the QESDP below
     class ModePrivate;
     class ApplicationPrivate;
 

src/libHeaven/CentralUI/ContainerWidgets/SplitterContainerWidget.cpp

@@ -93,4 +93,28 @@ namespace Heaven
         return mSplitter->orientation() == Qt::Vertical;
     }
 
+    QList<int> SplitterContainerWidget::transformedSizes()
+    {
+        QList<int> sizes = mSplitter->sizes();
+        int w = width();
+
+        for (int i = 0; i < sizes.count(); i++) {
+            sizes[i] = sizes[i] * 10000 / w;
+        }
+
+        return sizes;
+    }
+
+    void SplitterContainerWidget::setTransformedSizes(const QList<int> sizes)
+    {
+        QList<int> realSizes;
+        int w = width();
+
+        for (int i = 0; i < sizes.count(); i++) {
+            realSizes << sizes[i] * w / 10000;
+        }
+
+        mSplitter->setSizes(realSizes);
+    }
+
 }

src/libHeaven/CentralUI/ContainerWidgets/SplitterContainerWidget.hpp

@@ -46,6 +46,10 @@ namespace Heaven
         void setVertical( bool vert );
         bool isVertical() const;
 
+    public:
+        QList<int> transformedSizes();
+        void setTransformedSizes(const QList<int> sizes);
+
     private:
         MiniSplitter* mSplitter;
     };

src/libHeaven/CentralUI/States/WindowState.cpp

@@ -17,8 +17,12 @@
  */
 
 #include <QDebug>
+#include <QVariant>
+#include <QIODevice>
+#include <QByteArray>
 #include <QUuid>
 #include <QDomElement>
+#include <QStringBuilder>
 
 #include "libHeaven/App/Application.hpp"
 #include "libHeaven/App/PrimaryWindow.hpp"
@@ -42,6 +46,24 @@ namespace Heaven
         }
     }
 
+    WindowState::WindowState(WindowState* parent, WindowState* cloneFrom)
+        : mParent(parent)
+        , mCurrentContent(NULL)
+    {
+        Q_ASSERT(cloneFrom);
+
+        if (mParent) {
+            mParent->mChildren.append(Ptr(this));
+        }
+
+        mId = cloneFrom->mId;
+        mOptions = cloneFrom->mOptions;
+
+        foreach(const WindowState::Ptr& child, cloneFrom->children()) {
+            child->clone(this);
+        }
+    }
+
     WindowState::~WindowState()
     {
         Q_ASSERT( mChildren.count() == 0 );
@@ -125,12 +147,20 @@ namespace Heaven
 
     void WindowState::updateConfig()
     {
-        foreach( const WindowState::Ptr& ws, mChildren )
+        foreach(const WindowState::Ptr& ws, mChildren)
         {
             ws->updateConfig();
         }
     }
 
+    void WindowState::applyConfig()
+    {
+        foreach(const WindowState::Ptr& ws, mChildren)
+        {
+            ws->applyConfig();
+        }
+    }
+
     AbstractViewWidget* WindowState::currentContent()
     {
         return mCurrentContent;
@@ -174,4 +204,97 @@ namespace Heaven
         mId = id;
     }
 
+    void WindowState::readOptions(const QDomElement& el)
+    {
+        for (int i = 0; i < el.attributes().count(); i++) {
+            QDomAttr a = el.attributes().item(i).toAttr();
+            if (a.name().startsWith(QLatin1String("Opt"))) {
+                QString opt = a.name().mid(4);
+                QByteArray binData = a.value().toUtf8();
+                QDataStream stream(&binData, QIODevice::ReadOnly);
+                QVariant vData;
+                stream >> vData;
+                mOptions.insert(opt, vData);
+            }
+        }
+    }
+
+    void WindowState::saveOptions(QDomElement &el) const
+    {
+        foreach (QString name, mOptions.keys()) {
+            QVariant vData = mOptions.value(name);
+            QString sData;
+            QByteArray binData;
+            QDataStream stream(&binData, QIODevice::WriteOnly);
+            stream << vData;
+            sData = QString::fromUtf8(binData.constData());
+            el.setAttribute(QLatin1Literal("Opt") % name, sData);
+        }
+    }
+
+    void WindowState::setOption(const QString& name, const QVariant& vData)
+    {
+        mOptions[name] = vData;
+    }
+
+    void WindowState::unsetOption(const QString& name)
+    {
+        mOptions.remove(name);
+    }
+
+    QVariant WindowState::option(const QString& name) const
+    {
+        return mOptions.value(name, QVariant());
+    }
+
+    bool WindowState::isOptionSet(const QString& name) const
+    {
+        return mOptions.contains(name);
+    }
+
+    void WindowState::setWidget(QWidget* widget)
+    {
+        mWidget = widget;
+
+        if (mWidget) {
+            applyConfig();
+        }
+    }
+
+    void WindowState::clearWidgets()
+    {
+        if (mWidget) {
+            updateConfig();
+        }
+
+        mWidget = NULL;
+
+        foreach (WindowState::Ptr pChild, mChildren) {
+            pChild->clearWidgets();
+        }
+    }
+
+    QWidget* WindowState::widget() const
+    {
+        return mWidget;
+    }
+
+    Mode* WindowState::mode()
+    {
+        if (mParent) {
+            return mParent->mode();
+        }
+
+        return NULL;
+    }
+
+    WindowStateRoot* WindowState::root()
+    {
+        if (mParent) {
+            return mParent->root();
+        }
+
+        return NULL;
+    }
+
 }

src/libHeaven/CentralUI/States/WindowState.hpp

@@ -20,6 +20,8 @@
 #define HEAVEN_WINDOW_STATE_HPP
 
 #include <QSharedData>
+#include <QVariant>
+#include <QPointer>
 #include <QVector>
 #include <QSet>
 
@@ -31,6 +33,9 @@ class QDomElement;
 namespace Heaven
 {
 
+    class Mode;
+    class WindowStateRoot;
+
     class WindowState : public QSharedData
     {
     public:
@@ -55,6 +60,9 @@ namespace Heaven
     public:
         typedef QExplicitlySharedDataPointer< WindowState > Ptr;
 
+    protected:
+        WindowState(WindowState* parent, WindowState* cloneFrom);
+
     public:
         WindowState( WindowState* parent );
         virtual ~WindowState();
@@ -67,6 +75,13 @@ namespace Heaven
         QVector< WindowState::Ptr > children() const;
 
         virtual void updateConfig();
+        virtual void applyConfig();
+
+    public:
+        void setOption(const QString& name, const QVariant& vData);
+        void unsetOption(const QString& name);
+        QVariant option(const QString& name) const;
+        bool isOptionSet(const QString& name) const;
 
     public:
         ViewIdentifier identifier() const;
@@ -75,25 +90,39 @@ namespace Heaven
         void setCurrentContent( AbstractViewWidget* avw );
         AbstractViewWidget* currentContent();
 
+    public:
+        void setWidget(QWidget* widget);
+        QWidget* widget() const;
+        void clearWidgets();
+
+        virtual Mode* mode();
+        virtual WindowStateRoot* root();
+
     protected:
-        void readChildren( const QDomElement& elParent, ChildTypes allowed );
-        void readOrCreateIdentifier( const QDomElement& el );
+        void readOptions(const QDomElement& el);
+        void readChildren(const QDomElement& elParent, ChildTypes allowed);
+        void readOrCreateIdentifier(const QDomElement& el);
+
+        void saveChildren(QDomElement& elParent) const;
+        void saveIdentifier(QDomElement& el) const;
+        void saveOptions(QDomElement& el) const;
 
-        void saveChildren( QDomElement& elParent ) const;
-        void saveIdentifier( QDomElement& el ) const;
+        virtual WindowState* clone(WindowState* toParent) = 0;
 
     public:
         virtual void save( QDomElement& elParent ) const = 0;
 
     private:
         WindowState*                mParent;
-        AbstractViewWidget  *           mCurrentContent;
+        AbstractViewWidget*         mCurrentContent;
         QVector< WindowState::Ptr > mChildren;
-        ViewIdentifier                  mId;
+        ViewIdentifier              mId;
+        QVariantHash                mOptions;
+        QPointer< QWidget >         mWidget;
     };
 
 }
 
-Q_DECLARE_OPERATORS_FOR_FLAGS( Heaven::WindowState::ChildTypes );
+Q_DECLARE_OPERATORS_FOR_FLAGS(Heaven::WindowState::ChildTypes)
 
 #endif

src/libHeaven/CentralUI/States/WindowStateRoot.cpp

@@ -23,15 +23,32 @@ namespace Heaven
 
     WindowStateRoot::WindowStateRoot()
         : WindowState( NULL )
+        , mMode(NULL)
+        , mIsReadOnly(false)
     {
     }
 
     WindowStateRoot::WindowStateRoot( const QDomElement& elParent )
         : WindowState( NULL )
+        , mMode(NULL)
+        , mIsReadOnly(false)
     {
         load( elParent );
     }
 
+    WindowStateRoot::WindowStateRoot(WindowStateRoot* cloneFrom)
+        : WindowState(NULL, cloneFrom)
+    {
+        mMode = cloneFrom->mMode;
+        mIsReadOnly = true;
+    }
+
+    WindowStateRoot* WindowStateRoot::clone(WindowState* toParent)
+    {
+        Q_ASSERT(toParent == NULL);
+        return new WindowStateRoot(this);
+    }
+
     WindowStateRoot::~WindowStateRoot()
     {
     }
@@ -56,4 +73,29 @@ namespace Heaven
         readChildren( elParent, CTWindows );
     }
 
+    void WindowStateRoot::setMode(Mode* mode)
+    {
+        mMode = mode;
+    }
+
+    Mode* WindowStateRoot::mode()
+    {
+        return mMode;
+    }
+
+    WindowStateRoot* WindowStateRoot::root()
+    {
+        return this;
+    }
+
+    void WindowStateRoot::setReadOnly(bool ro)
+    {
+        mIsReadOnly = ro;
+    }
+
+    bool WindowStateRoot::isReadOnly() const
+    {
+        return mIsReadOnly;
+    }
+
 }