Merge branch 'master' into mod_notify_onbanwarn

README.md

@@ -14,10 +14,7 @@
 
 # Cockatrice
 
-Cockatrice is an open-source multiplatform software for playing card games,
-such as Magic: The Gathering, over a network. It is fully client-server based
-to prevent any kind of cheating, though it supports single-player games without
-a network interface as well. Both client and server are written in Qt, supporting both Qt4 and Qt5.<br>
+Cockatrice is an open-source multiplatform supported program for playing tabletop card games over a network. The program's server design prevents any kind of client modifications to gain an unfair advantage in a game. The client also has a built in single-player mode where you can brew without being connected to a server. This project is written in C++/Qt with support for both Qt4 and Qt5.<br>
 
 
 # Downloads

cmake/createversionfile.cmake

@@ -2,8 +2,10 @@ set(VERSION_STRING_CPP "${PROJECT_BINARY_DIR}/version_string.cpp")
 set(VERSION_STRING_H "${PROJECT_BINARY_DIR}/version_string.h")
 INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
 
-set( hstring "extern const char *VERSION_STRING\;\n" )
-set( cppstring "const char * VERSION_STRING = \"${PROJECT_VERSION_FRIENDLY}\"\;\n")
+set( hstring "extern const char *VERSION_STRING\;
+extern const char *VERSION_DATE\;\n" )
+set( cppstring "const char *VERSION_STRING = \"${PROJECT_VERSION_FRIENDLY}\"\;
+const char *VERSION_DATE = \"${GIT_COMMIT_DATE_FRIENDLY}\"\;\n")
 
 file(WRITE ${PROJECT_BINARY_DIR}/version_string.cpp.txt ${cppstring} )
 file(WRITE ${PROJECT_BINARY_DIR}/version_string.h.txt ${hstring} )

cockatrice/CMakeLists.txt

@@ -16,7 +16,8 @@ SET(cockatrice_SOURCES
     src/dlg_edit_tokens.cpp
     src/dlg_edit_user.cpp
     src/dlg_register.cpp 
-    src/abstractclient.cpp 
+    src/dlg_update.cpp
+    src/abstractclient.cpp
     src/remoteclient.cpp 
     src/main.cpp 
     src/window_main.cpp 
@@ -107,6 +108,8 @@ SET(cockatrice_SOURCES
     src/settings/messagesettings.cpp
     src/settings/gamefilterssettings.cpp
     src/settings/layoutssettings.cpp
+    src/update_checker.cpp
+    src/update_downloader.cpp
     ${VERSION_STRING_CPP}
 )
 

cockatrice/src/dlg_update.cpp

+#define HUMAN_DOWNLOAD_URL "https://bintray.com/cockatrice/Cockatrice/Cockatrice/_latestVersion"
+#define API_DOWNLOAD_BASE_URL "https://dl.bintray.com/cockatrice/Cockatrice/"
+#define DATE_LENGTH 10
+#define MAX_DATE_LENGTH 100
+#define SHORT_SHA1_HASH_LENGTH 7
+
+#include <QtNetwork>
+#include <QProgressDialog>
+#include <QDesktopServices>
+#include <QMessageBox>
+#include <QVBoxLayout>
+#include <QDialogButtonBox>
+#include <QPushButton>
+#include <QLabel>
+#include <QProgressBar>
+#include <QApplication>
+
+#include "dlg_update.h"
+#include "window_main.h"
+
+DlgUpdate::DlgUpdate(QWidget *parent) : QDialog(parent) {
+
+    //Handle layout
+    text = new QLabel(this);
+    progress = new QProgressBar(this);
+
+    QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
+    ok = new QPushButton("Ok", this);
+    manualDownload = new QPushButton("Update Anyway", this);
+    enableUpdateButton(false); //Unless we know there's an update available, you can't install
+    gotoDownload = new QPushButton("Open Download Page", this);
+    buttonBox->addButton(manualDownload, QDialogButtonBox::ActionRole);
+    buttonBox->addButton(gotoDownload, QDialogButtonBox::ActionRole);
+    buttonBox->addButton(ok, QDialogButtonBox::AcceptRole);
+
+    connect(gotoDownload, SIGNAL(clicked()), this, SLOT(gotoDownloadPage()));
+    connect(manualDownload, SIGNAL(clicked()), this, SLOT(downloadUpdate()));
+    connect(ok, SIGNAL(clicked()), this, SLOT(closeDialog()));
+
+    QVBoxLayout *parentLayout = new QVBoxLayout(this);
+    parentLayout->addWidget(text);
+    parentLayout->addWidget(progress);
+    parentLayout->addWidget(buttonBox);
+
+    setLayout(parentLayout);
+
+    //Check for SSL (this probably isn't necessary)
+    if (!QSslSocket::supportsSsl()) {
+        enableUpdateButton(false);
+        QMessageBox::critical(
+                this,
+                tr("Error"),
+                tr("Cockatrice was not built with SSL support, so cannot download updates! "
+                           "Please visit the download page and update manually."));
+    }
+
+    //Initialize the checker and downloader class
+    uDownloader = new UpdateDownloader(this);
+    connect(uDownloader, SIGNAL(downloadSuccessful(QUrl)), this, SLOT(downloadSuccessful(QUrl)));
+    connect(uDownloader, SIGNAL(progressMade(qint64, qint64)),
+            this, SLOT(downloadProgressMade(qint64, qint64)));
+    connect(uDownloader, SIGNAL(error(QString)),
+            this, SLOT(downloadError(QString)));
+
+    uChecker = new UpdateChecker(this);
+    connect(uChecker, SIGNAL(finishedCheck(bool, bool, QVariantMap * )),
+            this, SLOT(finishedUpdateCheck(bool, bool, QVariantMap * )));
+    connect(uChecker, SIGNAL(error(QString)),
+            this, SLOT(updateCheckError(QString)));
+
+    //Check for updates
+    beginUpdateCheck();
+}
+
+
+void DlgUpdate::closeDialog() {
+    accept();
+}
+
+
+void DlgUpdate::gotoDownloadPage() {
+    QUrl openUrl(HUMAN_DOWNLOAD_URL);
+    QDesktopServices::openUrl(openUrl);
+}
+
+void DlgUpdate::downloadUpdate() {
+    setLabel("Downloading update...");
+    enableUpdateButton(false);
+    uDownloader->beginDownload(updateUrl);
+}
+
+void DlgUpdate::beginUpdateCheck() {
+    progress->setMinimum(0);
+    progress->setMaximum(0);
+    setLabel("Checking for updates...");
+    uChecker->check();
+}
+
+void DlgUpdate::finishedUpdateCheck(bool needToUpdate, bool isCompatible, QVariantMap *build) {
+
+    QString commitHash, commitDate;
+
+    //Update the UI to say we've finished
+    progress->setMaximum(100);
+    setLabel("Finished checking for updates.");
+
+    //If there are no available builds, then they can't auto update.
+    enableUpdateButton(isCompatible);
+
+    //If there is an update, save its URL and work out its name
+    if (isCompatible) {
+        QString endUrl = (*build)["path"].toString();
+        updateUrl = API_DOWNLOAD_BASE_URL + endUrl;
+        commitHash = (*build)["sha1"].toString().left(SHORT_SHA1_HASH_LENGTH);
+        commitDate = (*build)["created"].toString().remove(DATE_LENGTH, MAX_DATE_LENGTH);
+    }
+
+    //Give the user the appropriate message
+    if (needToUpdate) {
+        if (isCompatible) {
+
+            QMessageBox::StandardButton reply;
+            reply = QMessageBox::question(this, "Update Available",
+                                          "A new build (commit " + commitHash + ") from " + commitDate +
+                                          " is available. Download?",
+                                          QMessageBox::Yes | QMessageBox::No);
+            if (reply == QMessageBox::Yes)
+                downloadUpdate();
+        }
+        else {
+            QMessageBox::information(this, "Cockatrice Update",
+                                     tr("Your version of Cockatrice is out of date, but there are no packages"
+                                                " available for your operating system. You may have to use a developer build or build from source"
+                                                " yourself. Please visit the download page."));
+        }
+    }
+    else {
+        //If there's no need to update, tell them that. However we still allow them to run the
+        //downloader themselves if there's a compatible build
+        QMessageBox::information(this, tr("Cockatrice Update"), tr("Your version of Cockatrice is up to date."));
+    }
+
+}
+
+void DlgUpdate::enableUpdateButton(bool enable) {
+    manualDownload->setEnabled(enable);
+}
+
+void DlgUpdate::setLabel(QString newText) {
+    text->setText(newText);
+}
+
+void DlgUpdate::updateCheckError(QString errorString) {
+    setLabel("Error");
+    QMessageBox::critical(this, tr("Update Error"), "An error occurred while checking for updates: " + errorString);
+}
+
+void DlgUpdate::downloadError(QString errorString) {
+    setLabel("Error");
+    enableUpdateButton(true);
+    QMessageBox::critical(this, tr("Update Error"), "An error occurred while downloading an update: " + errorString);
+}
+
+void DlgUpdate::downloadSuccessful(QUrl filepath) {
+    setLabel("Installing...");
+    //Try to open the installer. If it opens, quit Cockatrice
+    if (QDesktopServices::openUrl(filepath))
+    {
+        QMetaObject::invokeMethod((MainWindow*) parent(), "close", Qt::QueuedConnection);
+        close();
+    } else {
+        setLabel("Error");
+        QMessageBox::critical(this, tr("Update Error"), "Unable to open the installer. You might be able to manually update"
+                " by closing Cockatrice and running the installer at " + filepath.toLocalFile() + ".");
+    }
+}
+
+void DlgUpdate::downloadProgressMade(qint64 bytesRead, qint64 totalBytes) {
+    progress->setMaximum(totalBytes);
+    progress->setValue(bytesRead);
+}

cockatrice/src/dlg_update.h

+#ifndef DLG_UPDATE_H
+#define DLG_UPDATE_H
+
+#include <QtNetwork>
+#include <QProgressDialog>
+
+#include "update_checker.h"
+#include "update_downloader.h"
+
+class DlgUpdate : public QDialog {
+Q_OBJECT
+public:
+    DlgUpdate(QWidget *parent);
+
+private slots:
+    void finishedUpdateCheck(bool needToUpdate, bool isCompatible, QVariantMap *build);
+    void gotoDownloadPage();
+    void downloadUpdate();
+    void updateCheckError(QString errorString);
+    void downloadSuccessful(QUrl filepath);
+    void downloadProgressMade(qint64 bytesRead, qint64 totalBytes);
+    void downloadError(QString errorString);
+    void closeDialog();
+private:
+    QUrl updateUrl;
+    void enableUpdateButton(bool enable);
+    void beginUpdateCheck();
+    void setLabel(QString text);
+    QLabel *text;
+    QProgressBar *progress;
+    QPushButton *manualDownload, *gotoDownload, *ok;
+    QPushButton *cancel;
+    UpdateChecker *uChecker;
+    UpdateDownloader *uDownloader;
+};
+
+#endif

cockatrice/src/pictureloader.cpp

@@ -88,10 +88,10 @@ CardSet *PictureToLoad::getCurrentSet() const
         return 0;
 }
 
-QStringList PictureLoader::md5Blacklist = QStringList()
+QStringList PictureLoaderWorker::md5Blacklist = QStringList()
     << "db0c48db407a907c16ade38de048a441"; // card back returned by gatherer when card is not found
 
-PictureLoader::PictureLoader()
+PictureLoaderWorker::PictureLoaderWorker()
     : QObject(0),
       downloadRunning(false), loadQueueRunning(false)
 {
@@ -110,12 +110,12 @@ PictureLoader::PictureLoader()
     moveToThread(pictureLoaderThread);
 }
 
-PictureLoader::~PictureLoader()
+PictureLoaderWorker::~PictureLoaderWorker()
 {
     pictureLoaderThread->deleteLater();
 }
 
-void PictureLoader::processLoadQueue()
+void PictureLoaderWorker::processLoadQueue()
 {
     if (loadQueueRunning)
         return;
@@ -160,7 +160,7 @@ void PictureLoader::processLoadQueue()
     }
 }
 
-bool PictureLoader::cardImageExistsOnDisk(QString & setName, QString & correctedCardname)
+bool PictureLoaderWorker::cardImageExistsOnDisk(QString & setName, QString & correctedCardname)
 {
     QImage image;
     QImageReader imgReader;
@@ -194,7 +194,7 @@ bool PictureLoader::cardImageExistsOnDisk(QString & setName, QString & corrected
     return false;
 }
 
-QString PictureLoader::getPicUrl()
+QString PictureLoaderWorker::getPicUrl()
 {
     if (!picDownload) return QString("");
 
@@ -242,7 +242,7 @@ QString PictureLoader::getPicUrl()
     return picUrl;
 }
 
-void PictureLoader::startNextPicDownload()
+void PictureLoaderWorker::startNextPicDownload()
 {
     if (cardsToDownload.isEmpty()) {
         cardBeingDownloaded = 0;
@@ -267,7 +267,7 @@ void PictureLoader::startNextPicDownload()
     }
 }
 
-void PictureLoader::picDownloadFailed()
+void PictureLoaderWorker::picDownloadFailed()
 {
     if (cardBeingDownloaded.nextSet())
     {
@@ -283,13 +283,13 @@ void PictureLoader::picDownloadFailed()
     }
 }
 
-bool PictureLoader::imageIsBlackListed(const QByteArray &picData)
+bool PictureLoaderWorker::imageIsBlackListed(const QByteArray &picData)
 {
     QString md5sum = QCryptographicHash::hash(picData, QCryptographicHash::Md5).toHex();
     return md5Blacklist.contains(md5sum);
 }
 
-void PictureLoader::picDownloadFinished(QNetworkReply *reply)
+void PictureLoaderWorker::picDownloadFinished(QNetworkReply *reply)
 {
     if (reply->error()) {
         qDebug() << "Download failed:" << reply->errorString();
@@ -349,7 +349,7 @@ void PictureLoader::picDownloadFinished(QNetworkReply *reply)
     startNextPicDownload();
 }
 
-void PictureLoader::enqueueImageLoad(CardInfo *card)
+void PictureLoaderWorker::enqueueImageLoad(CardInfo *card)
 {
     QMutexLocker locker(&mutex);
 
@@ -367,20 +367,31 @@ void PictureLoader::enqueueImageLoad(CardInfo *card)
     emit startLoadQueue();
 }
 
-void PictureLoader::picDownloadChanged()
+void PictureLoaderWorker::picDownloadChanged()
 {
     QMutexLocker locker(&mutex);
     picDownload = settingsCache->getPicDownload();
-
-    QPixmapCache::clear();
 }
 
-void PictureLoader::picsPathChanged()
+void PictureLoaderWorker::picsPathChanged()
 {
     QMutexLocker locker(&mutex);
     picsPath = settingsCache->getPicsPath();
+}
 
-    QPixmapCache::clear();
+PictureLoader::PictureLoader()
+    : QObject(0)
+{
+    worker = new PictureLoaderWorker;
+    connect(settingsCache, SIGNAL(picsPathChanged()), this, SLOT(picsPathChanged()));
+    connect(settingsCache, SIGNAL(picDownloadChanged()), this, SLOT(picDownloadChanged()));
+
+    connect(worker, SIGNAL(imageLoaded(CardInfo *, const QImage &)), this, SLOT(imageLoaded(CardInfo *, const QImage &)));
+}
+
+PictureLoader::~PictureLoader()
+{
+    worker->deleteLater();
 }
 
 void PictureLoader::internalGetCardBackPixmap(QPixmap &pixmap, QSize size)
@@ -388,7 +399,7 @@ void PictureLoader::internalGetCardBackPixmap(QPixmap &pixmap, QSize size)
     QString backCacheKey = "_trice_card_back_" + QString::number(size.width()) + QString::number(size.height());
     if(!QPixmapCache::find(backCacheKey, &pixmap))
     {
-qDebug() << "cache fail for" << backCacheKey;
+        qDebug() << "cache fail for" << backCacheKey;
         pixmap = QPixmap("theme:cardback").scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation);
         QPixmapCache::insert(backCacheKey, pixmap);
     }    
@@ -425,7 +436,7 @@ void PictureLoader::getPixmap(QPixmap &pixmap, CardInfo *card, QSize size)
     if(card)
     {
         // add the card to the load queue
-        getInstance().enqueueImageLoad(card);
+        getInstance().worker->enqueueImageLoad(card);
     }
 }
 
@@ -471,6 +482,16 @@ void PictureLoader::cacheCardPixmaps(QList<CardInfo *> cards)
         if(QPixmapCache::find(key, &tmp))
             continue;
 
-        getInstance().enqueueImageLoad(card);
+        getInstance().worker->enqueueImageLoad(card);
     }
 }
+
+void PictureLoader::picDownloadChanged()
+{
+    QPixmapCache::clear();
+}
+
+void PictureLoader::picsPathChanged()
+{
+    QPixmapCache::clear();
+}
\ No newline at end of file

cockatrice/src/pictureloader.h

@@ -28,21 +28,14 @@ public:
     bool nextSet();
 };
 
-class PictureLoader : public QObject {
+class PictureLoaderWorker : public QObject {
 Q_OBJECT
 public:
-    static PictureLoader& getInstance()
-    {
-        static PictureLoader instance;
-        return instance;
-    }
-private:
-    PictureLoader();
-    ~PictureLoader();
-    // Don't implement
-    PictureLoader(PictureLoader const&);
-    void operator=(PictureLoader const&); 
+    PictureLoaderWorker();
+    ~PictureLoaderWorker();
 
+    void enqueueImageLoad(CardInfo *card);
+private:
     static QStringList md5Blacklist;
 
     QThread *pictureLoaderThread;
@@ -55,18 +48,9 @@ private:
     PictureToLoad cardBeingDownloaded;
     bool picDownload, downloadRunning, loadQueueRunning;
     void startNextPicDownload();
-    void imageLoaded(CardInfo *card, const QImage &image);
     QString getPicUrl();
     bool cardImageExistsOnDisk(QString & setName, QString & correctedCardname);
     bool imageIsBlackListed(const QByteArray &picData);
-public:
-    void enqueueImageLoad(CardInfo *card);
-    static void getPixmap(QPixmap &pixmap, CardInfo *card, QSize size);
-    static void clearPixmapCache(CardInfo *card);
-    static void clearPixmapCache();
-    static void cacheCardPixmaps(QList<CardInfo *> cards);
-protected:
-    static void internalGetCardBackPixmap(QPixmap &pixmap, QSize size);
 private slots:
     void picDownloadFinished(QNetworkReply *reply);
     void picDownloadFailed();
@@ -77,6 +61,36 @@ public slots:
     void processLoadQueue();
 signals:
     void startLoadQueue();
+    void imageLoaded(CardInfo *card, const QImage &image);
 };
 
+class PictureLoader : public QObject {
+Q_OBJECT
+public:
+    static PictureLoader& getInstance()
+    {
+        static PictureLoader instance;
+        return instance;
+    }
+private:
+    PictureLoader();
+    ~PictureLoader();
+    // Don't implement
+    PictureLoader(PictureLoader const&);
+    void operator=(PictureLoader const&); 
+
+    PictureLoaderWorker * worker;
+public:
+    static void getPixmap(QPixmap &pixmap, CardInfo *card, QSize size);
+    static void clearPixmapCache(CardInfo *card);
+    static void clearPixmapCache();
+    static void cacheCardPixmaps(QList<CardInfo *> cards);
+protected:
+    static void internalGetCardBackPixmap(QPixmap &pixmap, QSize size);
+private slots:
+    void picDownloadChanged();
+    void picsPathChanged();
+public slots:
+    void imageLoaded(CardInfo *card, const QImage &image);
+};
 #endif

cockatrice/src/settings/layoutssettings.cpp

@@ -57,3 +57,43 @@ void LayoutsSettings::setDeckEditorFilterSize(const QSize &value)
 {
     setValue(value,"layouts/deckEditor_FilterSize");
 }
+
+void LayoutsSettings::setGamePlayAreaGeometry(const QByteArray &value)
+{
+    setValue(value,"layouts/gameplayarea_geometry");
+}
+
+void LayoutsSettings::setGamePlayAreaState(const QByteArray &value)
+{
+    setValue(value,"layouts/gameplayarea_state");
+}
+
+const QByteArray LayoutsSettings::getGamePlayAreaLayoutState()
+{
+    return getValue("layouts/gameplayarea_state").toByteArray();
+}
+
+const QByteArray LayoutsSettings::getGamePlayAreaGeometry()
+{
+    return getValue("layouts/gameplayarea_geometry").toByteArray();
+}
+
+void LayoutsSettings::setReplayPlayAreaGeometry(const QByteArray &value)
+{
+    setValue(value,"layouts/replayplayarea_geometry");
+}
+
+void LayoutsSettings::setReplayPlayAreaState(const QByteArray &value)
+{
+    setValue(value,"layouts/replayplayarea_state");
+}
+
+const QByteArray LayoutsSettings::getReplayPlayAreaLayoutState()
+{
+    return getValue("layouts/replayplayarea_state").toByteArray();
+}
+
+const QByteArray LayoutsSettings::getReplayPlayAreaGeometry()
+{
+    return getValue("layouts/replayplayarea_geometry").toByteArray();
+}

cockatrice/src/settings/layoutssettings.h

@@ -15,12 +15,20 @@ public:
     void setDeckEditorCardSize(const QSize &value);
     void setDeckEditorDeckSize(const QSize &value);
     void setDeckEditorFilterSize(const QSize &value);
+    void setGamePlayAreaGeometry(const QByteArray &value);
+    void setGamePlayAreaState(const QByteArray &value);
+    void setReplayPlayAreaGeometry(const QByteArray &value);
+    void setReplayPlayAreaState(const QByteArray &value);
 
     const QByteArray getDeckEditorLayoutState();
     const QByteArray getDeckEditorGeometry();
     const QSize getDeckEditorCardSize();
     const QSize getDeckEditorDeckSize();
     const QSize getDeckEditorFilterSize();
+    const QByteArray getGamePlayAreaLayoutState();
+    const QByteArray getGamePlayAreaGeometry();
+    const QByteArray getReplayPlayAreaLayoutState();
+    const QByteArray getReplayPlayAreaGeometry();
 signals:
 
 public slots:

cockatrice/src/settingscache.cpp

@@ -612,4 +612,4 @@ void SettingsCache::setNotifyAboutUpdate(int _notifyaboutupdate)
 {
     notifyAboutUpdates = _notifyaboutupdate;
     settings->setValue("personal/updatenotification", notifyAboutUpdates);
-}
+}
\ No newline at end of file

cockatrice/src/shortcutssettings.cpp

@@ -243,4 +243,5 @@ void ShortcutsSettings::fillDefaultShorcuts()
     defaultShortCuts["Player/phase9"] = parseSequenceString("F9");
     defaultShortCuts["tab_room/aClearChat"] = parseSequenceString("F12");
     defaultShortCuts["DlgLoadDeckFromClipboard/refreshButton"] = parseSequenceString("F5");
+    defaultShortCuts["Player/aResetLayout"] = parseSequenceString("");
 }

cockatrice/src/soundengine.cpp

@@ -170,6 +170,8 @@ void SoundEngine::themeChangedSlot()
         << "player_join" << "player_leave" << "player_disconnect" << "player_reconnect" << "player_concede"
         // Spectator
         << "spectator_join" << "spectator_leave"
+        // Buddy
+        << "buddy_join" << "buddy_leave"
         // Chat & UI
         << "chat_mention" << "all_mention" << "private_message";
 

cockatrice/src/tab.cpp

@@ -4,8 +4,9 @@
 #include <QApplication>
 #include <QDebug>
 Tab::Tab(TabSupervisor *_tabSupervisor, QWidget *parent)
-    : QWidget(parent), tabSupervisor(_tabSupervisor), contentsChanged(false), infoPopup(0)
+    : QMainWindow(parent), tabSupervisor(_tabSupervisor), contentsChanged(false), infoPopup(0)
 {
+    setAttribute(Qt::WA_DeleteOnClose);
 }
 
 void Tab::showCardInfoPopup(const QPoint &pos, const QString &cardName)

cockatrice/src/tab.h

 #ifndef TAB_H
 #define TAB_H
 
-#include <QWidget>
+#include <QMainWindow>
 
 class QMenu;
 class TabSupervisor;
 class CardInfoWidget;
 
-class Tab : public QWidget {
+class Tab : public QMainWindow {
     Q_OBJECT
 signals:
     void userEvent(bool globalEvent = true);

cockatrice/src/tab_admin.cpp

@@ -83,7 +83,10 @@ TabAdmin::TabAdmin(TabSupervisor *_tabSupervisor, AbstractClient *_client, bool
     mainLayout->addWidget(lockButton);
     
     retranslateUi();
-    setLayout(mainLayout);
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(mainLayout);
+    setCentralWidget(mainWidget);
 }
 
 void TabAdmin::retranslateUi()

cockatrice/src/tab_deck_editor.cpp

@@ -52,30 +52,6 @@ void SearchLineEdit::keyPressEvent(QKeyEvent *event)
     QLineEdit::keyPressEvent(event);
 }
 
-void TabDeckEditor::createShowHideDocksButtons()
-{
-    btnFilter = new QPushButton(QPixmap("theme:icons/view"),QString());
-    btnFilter->setObjectName("btnFilter");
-    btnFilter->setCheckable(true);
-    btnFilter->setChecked(true);
-    btnFilter->setMaximumWidth(30);
-    searchLayout->addWidget(btnFilter);
-
-    btnDeck = new QPushButton(QPixmap("theme:hand"),QString());
-    btnDeck->setObjectName("btnDeck");
-    btnDeck->setCheckable(true);
-    btnDeck->setChecked(true);
-    btnDeck->setMaximumWidth(30);
-    searchLayout->addWidget(btnDeck);
-
-    btnCard = new QPushButton(QPixmap("theme:cardback"),QString());
-    btnCard->setObjectName("btnCard");
-    btnCard->setCheckable(true);
-    btnCard->setChecked(true);
-    btnCard->setMaximumWidth(30);
-    searchLayout->addWidget(btnCard);
-}
-
 void TabDeckEditor::createDeckDock()
 {
     deckModel = new DeckListModel(this);
@@ -160,7 +136,7 @@ void TabDeckEditor::createDeckDock()
     rightFrame->addWidget(deckView, 10);
     rightFrame->addLayout(deckToolbarLayout);
 
-    deckDock = new QDockWidget(MainWindow);
+    deckDock = new QDockWidget(this);
     deckDock->setObjectName("deckDock");
 
     deckDock->setMinimumSize(QSize(200, 41));
@@ -171,8 +147,8 @@ void TabDeckEditor::createDeckDock()
     deckDockContents->setLayout(rightFrame);
     deckDock->setWidget(deckDockContents);
 
-    connect(btnDeck,SIGNAL(toggled(bool)),deckDock,SLOT(setVisible(bool)));
     deckDock->installEventFilter(this);
+    connect(deckDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
 }
 
 void TabDeckEditor::createCardInfoDock()
@@ -183,7 +159,7 @@ void TabDeckEditor::createCardInfoDock()
     cardInfoFrame->setObjectName("cardInfoFrame");
     cardInfoFrame->addWidget(cardInfo);
 
-    cardInfoDock = new QDockWidget(MainWindow);
+    cardInfoDock = new QDockWidget(this);
     cardInfoDock->setObjectName("cardInfoDock");    
 
     cardInfoDock->setMinimumSize(QSize(200, 41));
@@ -194,8 +170,8 @@ void TabDeckEditor::createCardInfoDock()
     cardInfoDockContents->setLayout(cardInfoFrame);
     cardInfoDock->setWidget(cardInfoDockContents);
 
-    connect(btnCard,SIGNAL(toggled(bool)),cardInfoDock,SLOT(setVisible(bool)));
     cardInfoDock->installEventFilter(this);    
+    connect(cardInfoDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
 }
 
 void TabDeckEditor::createFiltersDock()
@@ -243,17 +219,17 @@ void TabDeckEditor::createFiltersDock()
     filterFrame->setObjectName("filterFrame");
     filterFrame->addWidget(filterBox);
 
-    filterDock = new QDockWidget(MainWindow);
+    filterDock = new QDockWidget(this);
     filterDock->setObjectName("filterDock");
 
     filterDock->setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetMovable);
-    QWidget *filterDockContents = new QWidget(MainWindow);
+    QWidget *filterDockContents = new QWidget(this);
     filterDockContents->setObjectName("filterDockContents");
     filterDockContents->setLayout(filterFrame);
     filterDock->setWidget(filterDockContents);    
 
-    connect(btnFilter,SIGNAL(toggled(bool)),filterDock,SLOT(setVisible(bool)));
     filterDock->installEventFilter(this);
+    connect(filterDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
 }
 
 void TabDeckEditor::createMenus()
@@ -297,9 +273,6 @@ void TabDeckEditor::createMenus()
     aEditTokens = new QAction(QString(), this);
     connect(aEditTokens, SIGNAL(triggered()), this, SLOT(actEditTokens()));
 
-    aResetLayout = new QAction(QString(), this);
-    connect(aResetLayout,SIGNAL(triggered()),this,SLOT(restartLayout()));
-
     deckMenu = new QMenu(this);
     deckMenu->addAction(aNewDeck);
     deckMenu->addAction(aLoadDeck);
@@ -313,8 +286,6 @@ void TabDeckEditor::createMenus()
     deckMenu->addSeparator();
     deckMenu->addAction(aAnalyzeDeck);
     deckMenu->addSeparator();
-    deckMenu->addAction(aResetLayout);
-    deckMenu->addSeparator();
     deckMenu->addAction(aClose);
     addTabMenu(deckMenu);
 
@@ -338,6 +309,41 @@ void TabDeckEditor::createMenus()
     dbMenu->addAction(aOpenCustomsetsFolder);
 #endif
     addTabMenu(dbMenu);
+
+    viewMenu = new QMenu(this);
+
+    cardInfoDockMenu = viewMenu->addMenu(QString());
+    deckDockMenu = viewMenu->addMenu(QString());
+    filterDockMenu = viewMenu->addMenu(QString());
+
+    aCardInfoDockVisible = cardInfoDockMenu->addAction(QString());
+    aCardInfoDockVisible->setCheckable(true);
+    connect(aCardInfoDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aCardInfoDockFloating = cardInfoDockMenu->addAction(QString());
+    aCardInfoDockFloating->setCheckable(true);
+    connect(aCardInfoDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    aDeckDockVisible = deckDockMenu->addAction(QString());
+    aDeckDockVisible->setCheckable(true);
+    connect(aDeckDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aDeckDockFloating = deckDockMenu->addAction(QString());
+    aDeckDockFloating->setCheckable(true);
+    connect(aDeckDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    aFilterDockVisible = filterDockMenu->addAction(QString());
+    aFilterDockVisible->setCheckable(true);
+    connect(aFilterDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aFilterDockFloating = filterDockMenu->addAction(QString());
+    aFilterDockFloating->setCheckable(true);
+    connect(aFilterDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    viewMenu->addSeparator();
+
+    aResetLayout = viewMenu->addAction(QString());
+    connect(aResetLayout,SIGNAL(triggered()),this,SLOT(restartLayout()));
+    viewMenu->addAction(aResetLayout);
+
+    addTabMenu(viewMenu);
 }
 
 void TabDeckEditor::createCentralFrame()
@@ -414,41 +420,43 @@ void TabDeckEditor::createCentralFrame()
     searchLayout->setObjectName("searchLayout");
     searchLayout->addWidget(deckEditToolBar);
     searchLayout->addWidget(searchEdit);
-    createShowHideDocksButtons();
 
     centralFrame = new QVBoxLayout;
     centralFrame->setObjectName("centralFrame");
     centralFrame->addLayout(searchLayout);
     centralFrame->addWidget(databaseView);
 
-    centralWidget = new QWidget(MainWindow);
+    centralWidget = new QWidget(this);
     centralWidget->setObjectName("centralWidget");
     centralWidget->setLayout(centralFrame);
-    MainWindow->setCentralWidget(centralWidget);
-    MainWindow->setDockOptions(QMainWindow::AnimatedDocks|QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks);
-
-    QHBoxLayout *mainLayout = new QHBoxLayout;
-    mainLayout->setObjectName("mainLayout");
-    mainLayout->addWidget(MainWindow);
-    setLayout(mainLayout);
+    setCentralWidget(centralWidget);
+    setDockOptions(QMainWindow::AnimatedDocks|QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks);
 }
 
 void TabDeckEditor::restartLayout()
 {
-    btnDeck->setChecked(true);
-    btnFilter->setChecked(true);
-    btnCard->setChecked(true);
+    deckDock->setVisible(true);
+    cardInfoDock->setVisible(true);
+    filterDock->setVisible(true);
 
     deckDock->setFloating(false);
     cardInfoDock->setFloating(false);
     filterDock->setFloating(false);
 
-    MainWindow->addDockWidget(static_cast<Qt::DockWidgetArea>(2), deckDock);
-    MainWindow->addDockWidget(static_cast<Qt::DockWidgetArea>(2), cardInfoDock);
-    MainWindow->addDockWidget(static_cast<Qt::DockWidgetArea>(2), filterDock);
+    aCardInfoDockVisible->setChecked(true);
+    aDeckDockVisible->setChecked(true);
+    aFilterDockVisible->setChecked(true);
 
-    MainWindow->splitDockWidget(cardInfoDock, deckDock, Qt::Horizontal);
-    MainWindow->splitDockWidget(cardInfoDock, filterDock, Qt::Vertical);
+    aCardInfoDockFloating->setChecked(false);
+    aDeckDockFloating->setChecked(false);
+    aFilterDockFloating->setChecked(false);
+
+    addDockWidget(static_cast<Qt::DockWidgetArea>(2), deckDock);
+    addDockWidget(static_cast<Qt::DockWidgetArea>(2), cardInfoDock);
+    addDockWidget(static_cast<Qt::DockWidgetArea>(2), filterDock);
+
+    splitDockWidget(cardInfoDock, deckDock, Qt::Horizontal);
+    splitDockWidget(cardInfoDock, filterDock, Qt::Vertical);
 
     deckDock->setMinimumWidth(360);
     deckDock->setMaximumWidth(360);
@@ -496,12 +504,20 @@ void TabDeckEditor::refreshShortcuts()
 
 void TabDeckEditor::loadLayout()
 {
-    MainWindow->restoreState(settingsCache->layouts().getDeckEditorLayoutState());
-    MainWindow->restoreGeometry(settingsCache->layouts().getDeckEditorGeometry());
+    restoreState(settingsCache->layouts().getDeckEditorLayoutState());
+    restoreGeometry(settingsCache->layouts().getDeckEditorGeometry());
+
+    aCardInfoDockVisible->setChecked(cardInfoDock->isVisible());
+    aFilterDockVisible->setChecked(filterDock->isVisible());
+    aDeckDockVisible->setChecked(deckDock->isVisible());
 
-    btnCard->setChecked(!cardInfoDock->isHidden());
-    btnFilter->setChecked(!filterDock->isHidden());
-    btnDeck->setChecked(!deckDock->isHidden());
+    aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
+    aDeckDockFloating->setEnabled(aDeckDockVisible->isChecked());
+    aFilterDockFloating->setEnabled(aFilterDockVisible->isChecked());
+
+    aCardInfoDockFloating->setChecked(cardInfoDock->isFloating());
+    aFilterDockFloating->setChecked(filterDock->isFloating());
+    aDeckDockFloating->setChecked(deckDock->isFloating());
 
     cardInfoDock->setMinimumSize(settingsCache->layouts().getDeckEditorCardSize());
     cardInfoDock->setMaximumSize(settingsCache->layouts().getDeckEditorCardSize());
@@ -518,8 +534,7 @@ void TabDeckEditor::loadLayout()
 TabDeckEditor::TabDeckEditor(TabSupervisor *_tabSupervisor, QWidget *parent)
     : Tab(_tabSupervisor, parent), modified(false)
 {
-    MainWindow = new QMainWindow;
-    MainWindow->setObjectName("MainWindow");
+    setObjectName("TabDeckEditor");
 
     createMenus();
 
@@ -587,13 +602,25 @@ void TabDeckEditor::retranslateUi()
     aEditSets->setText(tr("&Edit sets..."));
     aEditTokens->setText(tr("Edit &tokens..."));
 
-    btnCard->setToolTip(tr("Show/Hide card information"));
-    btnDeck->setToolTip(tr("Show/Hide deck"));
-    btnFilter->setToolTip(tr("Show/Hide filters"));
-    aResetLayout->setText(tr("Reset layout"));
     cardInfoDock->setWindowTitle(tr("Card Info"));
     deckDock->setWindowTitle(tr("Deck"));
     filterDock->setWindowTitle(tr("Filters"));
+
+    viewMenu->setTitle(tr("&View"));
+    cardInfoDockMenu->setTitle(tr("Card Info"));
+    deckDockMenu->setTitle(tr("Deck"));
+    filterDockMenu->setTitle(tr("Filters"));
+
+    aCardInfoDockVisible->setText(tr("Visible"));
+    aCardInfoDockFloating->setText(tr("Floating"));
+
+    aDeckDockVisible->setText(tr("Visible"));
+    aDeckDockFloating->setText(tr("Floating"));
+
+    aFilterDockVisible->setText(tr("Visible"));
+    aFilterDockFloating->setText(tr("Floating"));
+
+    aResetLayout->setText(tr("Reset layout"));
 }
 
 QString TabDeckEditor::getTabText() const
@@ -998,28 +1025,6 @@ void TabDeckEditor::setPriceTagFeatureEnabled(int /* enabled */)
     deckModel->pricesUpdated();
 }
 
-bool TabDeckEditor::eventFilter(QObject * o, QEvent * e)
-{
-    if(e->type() == QEvent::Close)
-    {
-        if(o == cardInfoDock)
-            btnCard->setChecked(false);
-        else if(o == deckDock)
-            btnDeck->setChecked(false);
-        else if(o == filterDock)
-            btnFilter->setChecked(false);            
-    }   
-    if( o == this && e->type() == QEvent::Hide){
-        settingsCache->layouts().setDeckEditorLayoutState(MainWindow->saveState());
-        settingsCache->layouts().setDeckEditorGeometry(MainWindow->saveGeometry());
-        settingsCache->layouts().setDeckEditorCardSize(cardInfoDock->size());
-        settingsCache->layouts().setDeckEditorFilterSize(filterDock->size());
-        settingsCache->layouts().setDeckEditorDeckSize(deckDock->size());
-    }
-    return false;
-}
-
-
 /*
 void TabDeckEditor::actUpdatePrices()
 {
@@ -1105,3 +1110,99 @@ void TabDeckEditor::checkFirstRunDetected()
         actEditSets();
     }
 }
+
+// Method uses to sync docks state with menu items state
+bool TabDeckEditor::eventFilter(QObject * o, QEvent * e)
+{
+    if(e->type() == QEvent::Close)
+    {
+        if(o == cardInfoDock)
+        {
+            aCardInfoDockVisible->setChecked(false);
+            aCardInfoDockFloating->setEnabled(false);
+        } else if(o == deckDock) {
+            aDeckDockVisible->setChecked(false);
+            aDeckDockFloating->setEnabled(false);
+        } else if(o == filterDock) {
+            aFilterDockVisible->setChecked(false);
+            aFilterDockFloating->setEnabled(false);
+        }
+    }   
+    if( o == this && e->type() == QEvent::Hide){
+        settingsCache->layouts().setDeckEditorLayoutState(saveState());
+        settingsCache->layouts().setDeckEditorGeometry(saveGeometry());
+        settingsCache->layouts().setDeckEditorCardSize(cardInfoDock->size());
+        settingsCache->layouts().setDeckEditorFilterSize(filterDock->size());
+        settingsCache->layouts().setDeckEditorDeckSize(deckDock->size());
+    }
+    return false;
+}
+
+void TabDeckEditor::dockVisibleTriggered()
+{
+    QObject *o = sender();
+    if(o == aCardInfoDockVisible)
+    {
+        cardInfoDock->setVisible(aCardInfoDockVisible->isChecked());
+        aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
+        return;
+    }
+
+    if(o == aDeckDockVisible)
+    {
+        deckDock->setVisible(aDeckDockVisible->isChecked());
+        aDeckDockFloating->setEnabled(aDeckDockVisible->isChecked());
+        return;
+    }
+
+    if(o == aFilterDockVisible)
+    {
+        filterDock->setVisible(aFilterDockVisible->isChecked());
+        aFilterDockFloating->setEnabled(aFilterDockVisible->isChecked());
+        return;
+    }
+}
+
+void TabDeckEditor::dockFloatingTriggered()
+{
+    QObject *o = sender();
+    if(o == aCardInfoDockFloating)
+    {
+        cardInfoDock->setFloating(aCardInfoDockFloating->isChecked());
+        return;
+    }
+
+    if(o == aDeckDockFloating)
+    {
+        deckDock->setFloating(aDeckDockFloating->isChecked());
+        return;
+    }
+
+    if(o == aFilterDockFloating)
+    {
+        filterDock->setFloating(aFilterDockFloating->isChecked());
+        return;
+    }
+}
+
+void TabDeckEditor::dockTopLevelChanged(bool topLevel)
+{
+    QObject *o = sender();
+    if(o == cardInfoDock)
+    {
+        aCardInfoDockFloating->setChecked(topLevel);
+        return;
+    }
+
+    if(o == deckDock)
+    {
+        aDeckDockFloating->setChecked(topLevel);
+        return;
+    }
+
+    if(o == filterDock)
+    {
+        aFilterDockFloating->setChecked(topLevel);
+        return;
+    }
+}

cockatrice/src/tab_deck_editor.h

@@ -22,7 +22,6 @@ class CardInfo;
 class QGroupBox;
 class QHBoxLayout;
 class QPushButton;
-class QMainWindow;
 class QDockWidget;
 
 class SearchLineEdit : public QLineEdit {
@@ -79,12 +78,15 @@ class TabDeckEditor : public Tab {
             void filterRemove(QAction *action);
             void setPriceTagFeatureEnabled(int enabled);
 
-            bool eventFilter(QObject *o, QEvent *e);
             void loadLayout();
             void restartLayout();
             void freeDocksSize();
             void refreshShortcuts();
 
+            bool eventFilter(QObject *o, QEvent *e);
+            void dockVisibleTriggered();
+            void dockFloatingTriggered();
+            void dockTopLevelChanged(bool topLevel);
 private:
     CardInfo *currentCardInfo() const;
     void addCardHelper(QString zoneName);
@@ -113,19 +115,16 @@ private:
     QTreeView *filterView;
     QWidget *filterBox;
 
-    QMenu *deckMenu, *dbMenu;
+    QMenu *deckMenu, *dbMenu, *viewMenu, *cardInfoDockMenu, *deckDockMenu, *filterDockMenu;
     QAction *aNewDeck, *aLoadDeck, *aSaveDeck, *aSaveDeckAs, *aLoadDeckFromClipboard, *aSaveDeckToClipboard, *aPrintDeck, *aAnalyzeDeck, *aClose, *aOpenCustomFolder, *aOpenCustomsetsFolder;
     QAction *aEditSets, *aEditTokens, *aClearFilterAll, *aClearFilterOne;
     QAction *aAddCard, *aAddCardToSideboard, *aRemoveCard, *aIncrement, *aDecrement;// *aUpdatePrices;
     QAction *aResetLayout;
+    QAction *aCardInfoDockVisible, *aCardInfoDockFloating, *aDeckDockVisible, *aDeckDockFloating, *aFilterDockVisible, *aFilterDockFloating;
 
     bool modified;
-    QMainWindow *MainWindow;
     QVBoxLayout *centralFrame;
     QHBoxLayout *searchLayout;
-    QPushButton *btnFilter;
-    QPushButton *btnDeck;
-    QPushButton *btnCard;
     QDockWidget *cardInfoDock;
     QDockWidget *deckDock;
     QDockWidget *filterDock;
@@ -138,7 +137,6 @@ public:
     void setDeck(DeckLoader *_deckLoader);
     void setModified(bool _windowModified);
     bool confirmClose();
-    void createShowHideDocksButtons();
     void createDeckDock();
     void createCardInfoDock();
     void createFiltersDock();

cockatrice/src/tab_deck_storage.cpp

@@ -110,7 +110,10 @@ TabDeckStorage::TabDeckStorage(TabSupervisor *_tabSupervisor, AbstractClient *_c
     rightToolBar->addAction(aDeleteRemoteDeck);
     
     retranslateUi();
-    setLayout(hbox);
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(hbox);
+    setCentralWidget(mainWidget);
 }
 
 void TabDeckStorage::retranslateUi()

cockatrice/src/tab_game.cpp

@@ -9,7 +9,9 @@
 #include <QToolButton>
 #include <QDebug>
 #include <QCompleter>
+#include <QDockWidget>
 #include <QWidget>
+#include <QStackedWidget>
 
 #include "dlg_creategame.h"
 #include "tab_game.h"
@@ -35,6 +37,7 @@
 #include "pictureloader.h"
 #include "replay_timeline_widget.h"
 #include "lineeditcompleter.h"
+#include "window_sets.h"
 
 #include <google/protobuf/descriptor.h>
 #include "pending_command.h"
@@ -93,7 +96,7 @@ void ToggleButton::setState(bool _state)
 }
 
 DeckViewContainer::DeckViewContainer(int _playerId, TabGame *parent)
-    : QWidget(parent), playerId(_playerId)
+    : QWidget(0), parentGame(parent), playerId(_playerId)
 {
     loadLocalButton = new QPushButton;
     loadRemoteButton = new QPushButton;
@@ -202,6 +205,9 @@ void TabGame::refreshShortcuts()
     if (aCloseReplay) {
         aCloseReplay->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aCloseReplay"));
     }
+    if (aResetLayout) {
+        aResetLayout->setShortcuts(settingsCache->shortcuts().getShortcut("Player/aResetLayout"));
+    }
 }
 
 void DeckViewContainer::loadLocalDeck()
@@ -222,20 +228,20 @@ void DeckViewContainer::loadLocalDeck()
     
     Command_DeckSelect cmd;
     cmd.set_deck(deck.writeToString_Native().toStdString());
-    PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
+    PendingCommand *pend = parentGame->prepareGameCommand(cmd);
     connect(pend, SIGNAL(finished(Response, CommandContainer, QVariant)), this, SLOT(deckSelectFinished(const Response &)));
-    static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
+    parentGame->sendGameCommand(pend, playerId);
 }
 
 void DeckViewContainer::loadRemoteDeck()
 {
-    DlgLoadRemoteDeck dlg(static_cast<TabGame *>(parent())->getClientForPlayer(playerId));
+    DlgLoadRemoteDeck dlg(parentGame->getClientForPlayer(playerId));
     if (dlg.exec()) {
         Command_DeckSelect cmd;
         cmd.set_deck_id(dlg.getDeckId());
-        PendingCommand *pend = static_cast<TabGame *>(parent())->prepareGameCommand(cmd);
+        PendingCommand *pend = parentGame->prepareGameCommand(cmd);
         connect(pend, SIGNAL(finished(Response, CommandContainer, QVariant)), this, SLOT(deckSelectFinished(const Response &)));
-        static_cast<TabGame *>(parent())->sendGameCommand(pend, playerId);
+        parentGame->sendGameCommand(pend, playerId);
     }
 }
 
@@ -251,7 +257,7 @@ void DeckViewContainer::readyStart()
 {
     Command_ReadyStart cmd;
     cmd.set_ready(!readyStartButton->getState());
-    static_cast<TabGame *>(parent())->sendGameCommand(cmd, playerId);
+    parentGame->sendGameCommand(cmd, playerId);
 }
 
 void DeckViewContainer::sideboardLockButtonClicked()
@@ -259,7 +265,7 @@ void DeckViewContainer::sideboardLockButtonClicked()
     Command_SetSideboardLock cmd;
     cmd.set_locked(sideboardLockButton->getState());
     
-    static_cast<TabGame *>(parent())->sendGameCommand(cmd, playerId);
+    parentGame->sendGameCommand(cmd, playerId);
 }
 
 void DeckViewContainer::sideboardPlanChanged()
@@ -268,7 +274,7 @@ void DeckViewContainer::sideboardPlanChanged()
     const QList<MoveCard_ToZone> &newPlan = deckView->getSideboardPlan();
     for (int i = 0; i < newPlan.size(); ++i)
         cmd.add_move_list()->CopyFrom(newPlan[i]);
-    static_cast<TabGame *>(parent())->sendGameCommand(cmd, playerId);
+    parentGame->sendGameCommand(cmd, playerId);
 }
 
 void DeckViewContainer::setReadyStart(bool ready)
@@ -310,11 +316,10 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, GameReplay *_replay)
     sayLabel(0),
     sayEdit(0)
 {
-    setAttribute(Qt::WA_DeleteOnClose);
-    
+    // THIS CTOR IS USED ON REPLAY
     gameInfo.CopyFrom(replay->game_info());
     gameInfo.set_spectators_omniscient(true);
-    
+
     // Create list: event number -> time [ms]
     // Distribute simultaneous events evenly across 1 second.
     unsigned int lastEventTimestamp = 0;
@@ -323,106 +328,41 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, GameReplay *_replay)
         int j = i + 1;
         while ((j < eventCount) && (replay->event_list(j).seconds_elapsed() == lastEventTimestamp))
             ++j;
-        
+
         const int numberEventsThisSecond = j - i;
         for (int k = 0; k < numberEventsThisSecond; ++k)
             replayTimeline.append(replay->event_list(i + k).seconds_elapsed() * 1000 + (int) ((qreal) k / (qreal) numberEventsThisSecond * 1000));
-        
+
         if (j < eventCount)
             lastEventTimestamp = replay->event_list(j).seconds_elapsed();
         i += numberEventsThisSecond - 1;
     }
-    
-    phasesToolbar = new PhasesToolbar;
-    
-    scene = new GameScene(phasesToolbar, this);
-    gameView = new GameView(scene);
-    gameView->hide();
-    
-    cardInfo = new CardFrame();
-    playerListWidget = new PlayerListWidget(0, 0, this);
-    playerListWidget->setFocusPolicy(Qt::NoFocus);
-    
-    messageLog = new MessageLogWidget(tabSupervisor, this);
-    connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString)));
-    connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
-    connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
-
-    deckViewContainerLayout = new QVBoxLayout;
 
-    QVBoxLayout *messageLogLayout = new QVBoxLayout;
-    messageLogLayout->setContentsMargins(0, 0, 0, 0);
-    messageLogLayout->addWidget(messageLog);
-    
-    QWidget *messageLogLayoutWidget = new QWidget;
-    messageLogLayoutWidget->setLayout(messageLogLayout);
-    
-    timelineWidget = new ReplayTimelineWidget;
-    timelineWidget->setTimeline(replayTimeline);
-    connect(timelineWidget, SIGNAL(processNextEvent()), this, SLOT(replayNextEvent()));
-    connect(timelineWidget, SIGNAL(replayFinished()), this, SLOT(replayFinished()));
-    
-    replayStartButton = new QToolButton;
-    replayStartButton->setIconSize(QSize(32, 32));
-    replayStartButton->setIcon(QPixmap("theme:replay/start"));
-    connect(replayStartButton, SIGNAL(clicked()), this, SLOT(replayStartButtonClicked()));
-    replayPauseButton = new QToolButton;
-    replayPauseButton->setIconSize(QSize(32, 32));
-    replayPauseButton->setEnabled(false);
-    replayPauseButton->setIcon(QPixmap("theme:replay/pause"));
-    connect(replayPauseButton, SIGNAL(clicked()), this, SLOT(replayPauseButtonClicked()));
-    replayFastForwardButton = new QToolButton;
-    replayFastForwardButton->setIconSize(QSize(32, 32));
-    replayFastForwardButton->setEnabled(false);
-    replayFastForwardButton->setIcon(QPixmap("theme:replay/fastforward"));
-    replayFastForwardButton->setCheckable(true);
-    connect(replayFastForwardButton, SIGNAL(toggled(bool)), this, SLOT(replayFastForwardButtonToggled(bool)));
-    
-    splitter = new QSplitter(Qt::Vertical);
-    splitter->addWidget(cardInfo);
-    splitter->addWidget(playerListWidget);
-    splitter->addWidget(messageLogLayoutWidget);
-
-    mainLayout = new QHBoxLayout;
-    mainLayout->addWidget(gameView, 10);
-    mainLayout->addLayout(deckViewContainerLayout, 10);
-    mainLayout->addWidget(splitter);
-    
-    QHBoxLayout *replayControlLayout = new QHBoxLayout;
-    replayControlLayout->addWidget(timelineWidget, 10);
-    replayControlLayout->addWidget(replayStartButton);
-    replayControlLayout->addWidget(replayPauseButton);
-    replayControlLayout->addWidget(replayFastForwardButton);
-    
-    QVBoxLayout *superMainLayout = new QVBoxLayout;
-    superMainLayout->addLayout(mainLayout);
-    superMainLayout->addLayout(replayControlLayout);
-    
-    aNextPhase = 0;
-    aNextTurn = 0;
-    aRemoveLocalArrows = 0;
-    aRotateViewCW = 0;
-    aRotateViewCCW = 0;
-    aGameInfo = 0;
-    aConcede = 0;
-    aLeaveGame = 0;
-    aCloseReplay = new QAction(this);
-    connect(aCloseReplay, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
-    
-    phasesMenu = 0;
-    gameMenu = new QMenu(this);
-    gameMenu->addAction(aCloseReplay);
-    addTabMenu(gameMenu);
-    
+    createCardInfoDock(true);
+    createPlayerListDock(true);
+    createMessageDock(true);
+    createPlayAreaWidget(true);
+    createDeckViewContainerWidget(true);
+    createReplayDock();
+
+    addDockWidget(Qt::RightDockWidgetArea, cardInfoDock);
+    addDockWidget(Qt::RightDockWidgetArea, playerListDock);
+    addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
+    addDockWidget(Qt::BottomDockWidgetArea, replayDock);
+
+    mainWidget = new QStackedWidget(this);
+    mainWidget->addWidget(deckViewContainerWidget);
+    mainWidget->addWidget(gamePlayAreaWidget);
+    setCentralWidget(mainWidget);
+
+    createReplayMenuItems();
+    createViewMenuItems();
     retranslateUi();
     connect(&settingsCache->shortcuts(), SIGNAL(shortCutchanged()),this,SLOT(refreshShortcuts()));
     refreshShortcuts();
-    setLayout(superMainLayout);
-
-    splitter->restoreState(settingsCache->getTabGameSplitterSizes());
-    splitter->setChildrenCollapsible(false);
-
     messageLog->logReplayStarted(gameInfo.game_id());
+
+    QTimer::singleShot(0, this, SLOT(loadLayout()));
 }
 
 TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event, const QMap<int, QString> &_roomGameTypes)
@@ -438,139 +378,39 @@ TabGame::TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_client
     currentPhase(-1),
     activeCard(0),
     gameClosed(false),
-    replay(0)
+    replay(0),
+    replayDock(0)
 {
+    // THIS CTOR IS USED ON GAMES
     gameInfo.set_started(false);
-    
-    gameTimer = new QTimer(this);
-    gameTimer->setInterval(1000);
-    connect(gameTimer, SIGNAL(timeout()), this, SLOT(incrementGameTime()));
-    gameTimer->start();
-    
-    phasesToolbar = new PhasesToolbar;
-    connect(phasesToolbar, SIGNAL(sendGameCommand(const ::google::protobuf::Message &, int)), this, SLOT(sendGameCommand(const ::google::protobuf::Message &, int)));
-    
-    scene = new GameScene(phasesToolbar, this);
-    gameView = new GameView(scene);
-    gameView->hide();
-    
-    cardInfo = new CardFrame();
-    playerListWidget = new PlayerListWidget(tabSupervisor, clients.first(), this);
-    playerListWidget->setFocusPolicy(Qt::NoFocus);
-    connect(playerListWidget, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
-    
-    timeElapsedLabel = new QLabel;
-    timeElapsedLabel->setAlignment(Qt::AlignCenter);
-    messageLog = new MessageLogWidget(tabSupervisor, this);
-    connect(messageLog, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
-    connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString)));
-    connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
-    connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
-    connect(messageLog, SIGNAL(addMentionTag(QString)), this, SLOT(addMentionTag(QString)));
-    connect(settingsCache, SIGNAL(chatMentionCompleterChanged()), this, SLOT(actCompleterChanged()));
-    sayLabel = new QLabel;
-    sayEdit = new LineEditCompleter;
-    sayLabel->setBuddy(sayEdit);
-
-    QHBoxLayout *hLayout = new QHBoxLayout;
-    hLayout->addWidget(sayLabel);
-    hLayout->addWidget(sayEdit);
-    
-    deckViewContainerLayout = new QVBoxLayout;
 
-    QVBoxLayout *messageLogLayout = new QVBoxLayout;
-    messageLogLayout->setContentsMargins(0, 0, 0, 0);
-    messageLogLayout->addWidget(timeElapsedLabel);
-    messageLogLayout->addWidget(messageLog);
-    messageLogLayout->addLayout(hLayout);
-    
-    QWidget *messageLogLayoutWidget = new QWidget;
-    messageLogLayoutWidget->setLayout(messageLogLayout);
-    
-    splitter = new QSplitter(Qt::Vertical);
-    splitter->addWidget(cardInfo);
-    splitter->addWidget(playerListWidget);
-    splitter->addWidget(messageLogLayoutWidget);
-
-    mainLayout = new QHBoxLayout;
-    mainLayout->addWidget(gameView, 10);
-    mainLayout->addLayout(deckViewContainerLayout, 10);
-    mainLayout->addWidget(splitter);
-    
-    if (spectator && !gameInfo.spectators_can_chat() && tabSupervisor->getAdminLocked()) {
-        sayLabel->hide();
-        sayEdit->hide();
-    }
-    connect(tabSupervisor, SIGNAL(adminLockChanged(bool)), this, SLOT(adminLockChanged(bool)));
-    connect(sayEdit, SIGNAL(returnPressed()), this, SLOT(actSay()));
+    createCardInfoDock();
+    createPlayerListDock();
+    createMessageDock();
+    createPlayAreaWidget();
+    createDeckViewContainerWidget();
 
-    // Menu actions
-    aNextPhase = new QAction(this);
-    connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
-    aNextTurn = new QAction(this);
-    connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
-    aRemoveLocalArrows = new QAction(this);
-    connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
-    aRotateViewCW = new QAction(this);
-    connect(aRotateViewCW, SIGNAL(triggered()), this, SLOT(actRotateViewCW()));
-    aRotateViewCCW = new QAction(this);
-    connect(aRotateViewCCW, SIGNAL(triggered()), this, SLOT(actRotateViewCCW()));
-    aGameInfo = new QAction(this);
-    connect(aGameInfo, SIGNAL(triggered()), this, SLOT(actGameInfo()));
-    aConcede = new QAction(this);
-    connect(aConcede, SIGNAL(triggered()), this, SLOT(actConcede()));
-    aLeaveGame = new QAction(this);
-    connect(aLeaveGame, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
-    aCloseReplay = 0;
-    
-    phasesMenu = new QMenu(this);
-    for (int i = 0; i < phasesToolbar->phaseCount(); ++i) {
-        QAction *temp = new QAction(QString(), this);
-        connect(temp, SIGNAL(triggered()), this, SLOT(actPhaseAction()));
-        phasesMenu->addAction(temp);
-        phaseActions.append(temp);
-    }
+    addDockWidget(Qt::RightDockWidgetArea, cardInfoDock);
+    addDockWidget(Qt::RightDockWidgetArea, playerListDock);
+    addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
 
-    phasesMenu->addSeparator();
-    phasesMenu->addAction(aNextPhase);
-    
-    gameMenu = new QMenu(this);
-    playersSeparator = gameMenu->addSeparator();
-    gameMenu->addMenu(phasesMenu);
-    gameMenu->addAction(aNextTurn);
-    gameMenu->addSeparator();
-    gameMenu->addAction(aRemoveLocalArrows);
-    gameMenu->addAction(aRotateViewCW);
-    gameMenu->addAction(aRotateViewCCW);
-    gameMenu->addSeparator();
-    gameMenu->addAction(aGameInfo);
-    gameMenu->addAction(aConcede);
-    gameMenu->addAction(aLeaveGame);
-    addTabMenu(gameMenu);
-    
+    mainWidget = new QStackedWidget(this);
+    mainWidget->addWidget(deckViewContainerWidget);
+    mainWidget->addWidget(gamePlayAreaWidget);
+    setCentralWidget(mainWidget);
+
+    createMenuItems();
+    createViewMenuItems();
     retranslateUi();
     connect(&settingsCache->shortcuts(), SIGNAL(shortCutchanged()),this,SLOT(refreshShortcuts()));
     refreshShortcuts();
-    setLayout(mainLayout);
-
-    splitter->restoreState(settingsCache->getTabGameSplitterSizes());
-    splitter->setChildrenCollapsible(false);
-    
     messageLog->logGameJoined(gameInfo.game_id());
 
+    // append game to rooms game list for others to see
     for (int i = gameInfo.game_types_size() - 1; i >= 0; i--)
         gameTypes.append(roomGameTypes.find(gameInfo.game_types(i)).value());
 
-    completer = new QCompleter(autocompleteUserList, sayEdit);
-    completer->setCaseSensitivity(Qt::CaseInsensitive);
-    completer->setMaxVisibleItems(5);
-
-    #if QT_VERSION >= 0x050000
-        completer->setFilterMode(Qt::MatchStartsWith);
-    #endif
-
-    sayEdit->setCompleter(completer);
-    actCompleterChanged();
+    QTimer::singleShot(0, this, SLOT(loadLayout()));
 }
 
 void TabGame::addMentionTag(QString value) {
@@ -585,21 +425,34 @@ void TabGame::emitUserEvent() {
 
 TabGame::~TabGame()
 {
-    delete replay;
-    settingsCache->setTabGameSplitterSizes(splitter->saveState());
+    if(replay)
+    {
+        settingsCache->layouts().setReplayPlayAreaState(saveState());
+        settingsCache->layouts().setReplayPlayAreaGeometry(saveGeometry());
+        delete replay;
+    } else {
+        settingsCache->layouts().setGamePlayAreaState(saveState());
+        settingsCache->layouts().setGamePlayAreaGeometry(saveGeometry());
+    }
 
     QMapIterator<int, Player *> i(players);
     while (i.hasNext())
         delete i.next().value();
     players.clear();
     
-    delete deckViewContainerLayout;
-    
     emit gameClosing(this);
 }
 
 void TabGame::retranslateUi()
 {
+    QString tabText = getTabText() + " - ";
+
+    cardInfoDock->setWindowTitle((cardInfoDock->isWindow() ? tabText : QString()) + tr("Card Info"));
+    playerListDock->setWindowTitle((playerListDock->isWindow() ? tabText : QString()) + tr("Player List"));
+    messageLayoutDock->setWindowTitle((messageLayoutDock->isWindow() ? tabText : QString()) + tr("Messages"));
+    if(replayDock)
+        replayDock->setWindowTitle((replayDock->isWindow() ? tabText : QString()) + tr("Replay Timeline"));
+
     if (phasesMenu) {
         for (int i = 0; i < phaseActions.size(); ++i)
             phaseActions[i]->setText(phasesToolbar->getLongPhaseName(i));
@@ -633,9 +486,33 @@ void TabGame::retranslateUi()
     if (aCloseReplay) {
         aCloseReplay->setText(tr("C&lose replay"));
     }
-    
-    if (sayLabel)
+    if (sayLabel){
         sayLabel->setText(tr("&Say:"));
+    }
+
+    viewMenu->setTitle(tr("&View"));
+    cardInfoDockMenu->setTitle(tr("Card Info"));
+    messageLayoutDockMenu->setTitle(tr("Messages"));
+    playerListDockMenu->setTitle(tr("Player List"));
+
+    aCardInfoDockVisible->setText(tr("Visible"));
+    aCardInfoDockFloating->setText(tr("Floating"));
+
+    aMessageLayoutDockVisible->setText(tr("Visible"));
+    aMessageLayoutDockFloating->setText(tr("Floating"));
+
+    aPlayerListDockVisible->setText(tr("Visible"));
+    aPlayerListDockFloating->setText(tr("Floating"));
+
+    if(replayDock)
+    {    
+        replayDockMenu->setTitle(tr("Replay Timeline"));
+        aReplayDockVisible->setText(tr("Visible"));
+        aReplayDockFloating->setText(tr("Floating"));
+    }
+
+    aResetLayout->setText(tr("Reset layout"));
+
     cardInfo->retranslateUi();
 
     QMapIterator<int, Player *> i(players);
@@ -955,8 +832,9 @@ void TabGame::startGame(bool resuming)
         i.value()->setReadyStart(false);
         i.value()->hide();
     }
-    mainLayout->removeItem(deckViewContainerLayout);
-    
+
+    mainWidget->setCurrentWidget(gamePlayAreaWidget);
+
     if (!resuming) {
         QMapIterator<int, Player *> playerIterator(players);
         while (playerIterator.hasNext())
@@ -966,7 +844,6 @@ void TabGame::startGame(bool resuming)
     playerListWidget->setGameStarted(true, resuming);
     gameInfo.set_started(true);
     static_cast<GameScene *>(gameView->scene())->rearrange();
-    gameView->show();
     if(sayEdit && players.size() > 1)
         sayEdit->setFocus();
 }
@@ -981,12 +858,12 @@ void TabGame::stopGame()
         i.next();
         i.value()->show();
     }
-    mainLayout->insertLayout(1, deckViewContainerLayout, 10);
+
+    mainWidget->setCurrentWidget(deckViewContainerWidget);
 
     playerListWidget->setActivePlayer(-1);
     playerListWidget->setGameStarted(false, false);
     gameInfo.set_started(false);
-    gameView->hide();
 }
 
 void TabGame::closeGame()
@@ -1335,3 +1212,478 @@ void TabGame::updateCardMenu(AbstractCardItem *card)
         p = players.value(localPlayerId);
     p->updateCardMenu(static_cast<CardItem *>(card));
 }
+
+void TabGame::createMenuItems()
+{
+    aNextPhase = new QAction(this);
+    connect(aNextPhase, SIGNAL(triggered()), this, SLOT(actNextPhase()));
+    aNextTurn = new QAction(this);
+    connect(aNextTurn, SIGNAL(triggered()), this, SLOT(actNextTurn()));
+    aRemoveLocalArrows = new QAction(this);
+    connect(aRemoveLocalArrows, SIGNAL(triggered()), this, SLOT(actRemoveLocalArrows()));
+    aRotateViewCW = new QAction(this);
+    connect(aRotateViewCW, SIGNAL(triggered()), this, SLOT(actRotateViewCW()));
+    aRotateViewCCW = new QAction(this);
+    connect(aRotateViewCCW, SIGNAL(triggered()), this, SLOT(actRotateViewCCW()));
+    aGameInfo = new QAction(this);
+    connect(aGameInfo, SIGNAL(triggered()), this, SLOT(actGameInfo()));
+    aConcede = new QAction(this);
+    connect(aConcede, SIGNAL(triggered()), this, SLOT(actConcede()));
+    aLeaveGame = new QAction(this);
+    connect(aLeaveGame, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
+    aCloseReplay = 0;
+
+    phasesMenu = new QMenu(this);
+    for (int i = 0; i < phasesToolbar->phaseCount(); ++i) {
+        QAction *temp = new QAction(QString(), this);
+        connect(temp, SIGNAL(triggered()), this, SLOT(actPhaseAction()));
+        phasesMenu->addAction(temp);
+        phaseActions.append(temp);
+    }
+
+    phasesMenu->addSeparator();
+    phasesMenu->addAction(aNextPhase);
+
+    gameMenu = new QMenu(this);
+    playersSeparator = gameMenu->addSeparator();
+    gameMenu->addMenu(phasesMenu);
+    gameMenu->addAction(aNextTurn);
+    gameMenu->addSeparator();
+    gameMenu->addAction(aRemoveLocalArrows);
+    gameMenu->addAction(aRotateViewCW);
+    gameMenu->addAction(aRotateViewCCW);
+    gameMenu->addSeparator();
+    gameMenu->addAction(aGameInfo);
+    gameMenu->addAction(aConcede);
+    gameMenu->addAction(aLeaveGame);
+    addTabMenu(gameMenu);
+}
+
+void TabGame::createReplayMenuItems()
+{
+    aNextPhase = 0;
+    aNextTurn = 0;
+    aRemoveLocalArrows = 0;
+    aRotateViewCW = 0;
+    aRotateViewCCW = 0;
+    aResetLayout = 0;
+    aGameInfo = 0;
+    aConcede = 0;
+    aLeaveGame = 0;
+    aCloseReplay = new QAction(this);
+    connect(aCloseReplay, SIGNAL(triggered()), this, SLOT(actLeaveGame()));
+
+    phasesMenu = 0;
+    gameMenu = new QMenu(this);
+    gameMenu->addAction(aCloseReplay);
+    addTabMenu(gameMenu);
+}
+
+void TabGame::createViewMenuItems()
+{
+    viewMenu = new QMenu(this);
+
+    cardInfoDockMenu = viewMenu->addMenu(QString());
+    messageLayoutDockMenu = viewMenu->addMenu(QString());
+    playerListDockMenu = viewMenu->addMenu(QString());
+
+    aCardInfoDockVisible = cardInfoDockMenu->addAction(QString());
+    aCardInfoDockVisible->setCheckable(true);
+    connect(aCardInfoDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aCardInfoDockFloating = cardInfoDockMenu->addAction(QString());
+    aCardInfoDockFloating->setCheckable(true);
+    connect(aCardInfoDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    aMessageLayoutDockVisible = messageLayoutDockMenu->addAction(QString());
+    aMessageLayoutDockVisible->setCheckable(true);
+    connect(aMessageLayoutDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aMessageLayoutDockFloating = messageLayoutDockMenu->addAction(QString());
+    aMessageLayoutDockFloating->setCheckable(true);
+    connect(aMessageLayoutDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    aPlayerListDockVisible = playerListDockMenu->addAction(QString());
+    aPlayerListDockVisible->setCheckable(true);
+    connect(aPlayerListDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+    aPlayerListDockFloating = playerListDockMenu->addAction(QString());
+    aPlayerListDockFloating->setCheckable(true);
+    connect(aPlayerListDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+
+    if(replayDock)
+    {
+        replayDockMenu = viewMenu->addMenu(QString());
+
+        aReplayDockVisible = replayDockMenu->addAction(QString());
+        aReplayDockVisible->setCheckable(true);
+        connect(aReplayDockVisible,SIGNAL(triggered()),this,SLOT(dockVisibleTriggered()));
+        aReplayDockFloating = replayDockMenu->addAction(QString());
+        aReplayDockFloating->setCheckable(true);
+        connect(aReplayDockFloating,SIGNAL(triggered()),this,SLOT(dockFloatingTriggered()));
+    }
+
+    viewMenu->addSeparator();
+
+    aResetLayout = viewMenu->addAction(QString());
+    connect(aResetLayout,SIGNAL(triggered()),this,SLOT(actResetLayout()));
+    viewMenu->addAction(aResetLayout);
+
+    addTabMenu(viewMenu);
+}
+
+void TabGame::loadLayout()
+{
+    if(replayDock)
+    {
+        restoreGeometry(settingsCache->layouts().getReplayPlayAreaGeometry());
+        restoreState(settingsCache->layouts().getReplayPlayAreaLayoutState());
+    } else {
+        restoreGeometry(settingsCache->layouts().getGamePlayAreaGeometry());
+        restoreState(settingsCache->layouts().getGamePlayAreaLayoutState());
+    }
+
+    aCardInfoDockVisible->setChecked(cardInfoDock->isVisible());
+    aMessageLayoutDockVisible->setChecked(messageLayoutDock->isVisible());
+    aPlayerListDockVisible->setChecked(playerListDock->isVisible());
+
+    aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
+    aMessageLayoutDockFloating->setEnabled(aMessageLayoutDockVisible->isChecked());
+    aPlayerListDockFloating->setEnabled(aPlayerListDockVisible->isChecked());
+
+    aCardInfoDockFloating->setChecked(cardInfoDock->isFloating());
+    aMessageLayoutDockFloating->setChecked(messageLayoutDock->isFloating());
+    aPlayerListDockFloating->setChecked(playerListDock->isFloating());
+
+    if(replayDock)
+    {
+        aReplayDockVisible->setChecked(replayDock->isVisible());
+        aReplayDockFloating->setEnabled(aReplayDockVisible->isChecked());
+        aReplayDockFloating->setChecked(replayDock->isFloating());
+    }
+}
+
+void TabGame::actResetLayout()
+{
+    cardInfoDock->setVisible(true);
+    playerListDock->setVisible(true);
+    messageLayoutDock->setVisible(true);
+
+    cardInfoDock->setFloating(false);
+    playerListDock->setFloating(false);
+    messageLayoutDock->setFloating(false);
+
+    aCardInfoDockVisible->setChecked(true);
+    aPlayerListDockVisible->setChecked(true);
+    aMessageLayoutDockVisible->setChecked(true);
+
+    aCardInfoDockFloating->setChecked(false);
+    aPlayerListDockFloating->setChecked(false);
+    aMessageLayoutDockFloating->setChecked(false);
+
+    addDockWidget(Qt::RightDockWidgetArea, cardInfoDock);
+    addDockWidget(Qt::RightDockWidgetArea, playerListDock);
+    addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
+
+    if(replayDock)
+    {
+        replayDock->setVisible(true);
+        replayDock->setFloating(false);
+        addDockWidget(Qt::BottomDockWidgetArea, replayDock);
+        aReplayDockVisible->setChecked(true);
+        aReplayDockFloating->setChecked(false);
+    }
+}
+
+void TabGame::createPlayAreaWidget(bool bReplay)
+{
+    phasesToolbar = new PhasesToolbar;
+    if(!bReplay)
+        connect(phasesToolbar, SIGNAL(sendGameCommand(const ::google::protobuf::Message &, int)), this, SLOT(sendGameCommand(const ::google::protobuf::Message &, int)));
+    scene = new GameScene(phasesToolbar, this);
+    gameView = new GameView(scene);
+
+    gamePlayAreaVBox = new QVBoxLayout;
+    gamePlayAreaVBox->addWidget(gameView);
+
+    gamePlayAreaWidget = new QWidget;
+    gamePlayAreaWidget->setObjectName("gamePlayAreaWidget");
+    gamePlayAreaWidget->setLayout(gamePlayAreaVBox);
+}
+
+void TabGame::createReplayDock()
+{
+    timelineWidget = new ReplayTimelineWidget;
+    timelineWidget->setTimeline(replayTimeline);
+    connect(timelineWidget, SIGNAL(processNextEvent()), this, SLOT(replayNextEvent()));
+    connect(timelineWidget, SIGNAL(replayFinished()), this, SLOT(replayFinished()));
+
+    replayStartButton = new QToolButton;
+    replayStartButton->setIconSize(QSize(32, 32));
+    replayStartButton->setIcon(QPixmap("theme:replay/start"));
+    connect(replayStartButton, SIGNAL(clicked()), this, SLOT(replayStartButtonClicked()));
+    replayPauseButton = new QToolButton;
+    replayPauseButton->setIconSize(QSize(32, 32));
+    replayPauseButton->setEnabled(false);
+    replayPauseButton->setIcon(QPixmap("theme:replay/pause"));
+    connect(replayPauseButton, SIGNAL(clicked()), this, SLOT(replayPauseButtonClicked()));
+    replayFastForwardButton = new QToolButton;
+    replayFastForwardButton->setIconSize(QSize(32, 32));
+    replayFastForwardButton->setEnabled(false);
+    replayFastForwardButton->setIcon(QPixmap("theme:replay/fastforward"));
+    replayFastForwardButton->setCheckable(true);
+    connect(replayFastForwardButton, SIGNAL(toggled(bool)), this, SLOT(replayFastForwardButtonToggled(bool)));
+
+    replayControlLayout = new QHBoxLayout;
+    replayControlLayout->addWidget(timelineWidget, 10);
+    replayControlLayout->addWidget(replayStartButton);
+    replayControlLayout->addWidget(replayPauseButton);
+    replayControlLayout->addWidget(replayFastForwardButton);
+
+    replayControlWidget = new QWidget();
+    replayControlWidget->setObjectName("replayControlWidget");
+    replayControlWidget->setLayout(replayControlLayout);
+
+    replayDock = new QDockWidget(this);
+    replayDock->setObjectName("replayDock");
+    replayDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
+    replayDock->setWidget(replayControlWidget);
+    replayDock->setFloating(false);
+
+    replayDock->installEventFilter(this);
+    connect(replayDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
+}
+
+void TabGame::createDeckViewContainerWidget(bool bReplay)
+{
+    Q_UNUSED(bReplay);
+
+    deckViewContainerWidget = new QWidget();
+    deckViewContainerWidget->setObjectName("deckViewContainerWidget");
+    deckViewContainerLayout = new QVBoxLayout;
+    deckViewContainerWidget->setLayout(deckViewContainerLayout);
+}
+
+void TabGame::createCardInfoDock(bool bReplay)
+{
+    Q_UNUSED(bReplay);
+
+    cardInfo = new CardFrame();
+    cardHInfoLayout = new QHBoxLayout;
+    cardVInfoLayout = new QVBoxLayout;
+    cardVInfoLayout->setContentsMargins(0, 0, 0, 0);
+    cardVInfoLayout->addWidget(cardInfo);
+    cardVInfoLayout->addLayout(cardHInfoLayout);
+
+    cardBoxLayoutWidget = new QWidget;
+    cardBoxLayoutWidget->setLayout(cardVInfoLayout);
+
+    cardInfoDock = new QDockWidget(this);
+    cardInfoDock->setObjectName("cardInfoDock");
+    cardInfoDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
+    cardInfoDock->setWidget(cardBoxLayoutWidget);
+    cardInfoDock->setFloating(false);
+
+    cardInfoDock->installEventFilter(this);
+    connect(cardInfoDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
+}
+
+void TabGame::createPlayerListDock(bool bReplay)
+{
+    if(bReplay)
+    {
+        playerListWidget = new PlayerListWidget(0, 0, this);
+    } else {
+        playerListWidget = new PlayerListWidget(tabSupervisor, clients.first(), this);
+        connect(playerListWidget, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
+    }
+    playerListWidget->setFocusPolicy(Qt::NoFocus);
+
+    playerListDock = new QDockWidget(this);
+    playerListDock->setObjectName("playerListDock");
+    playerListDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
+    playerListDock->setWidget(playerListWidget);
+    playerListDock->setFloating(false);
+
+    playerListDock->installEventFilter(this);  
+    connect(playerListDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
+}
+
+void TabGame::createMessageDock(bool bReplay)
+{
+    messageLog = new MessageLogWidget(tabSupervisor, this);
+    connect(messageLog, SIGNAL(cardNameHovered(QString)), cardInfo, SLOT(setCard(QString)));
+    connect(messageLog, SIGNAL(showCardInfoPopup(QPoint, QString)), this, SLOT(showCardInfoPopup(QPoint, QString)));
+    connect(messageLog, SIGNAL(deleteCardInfoPopup(QString)), this, SLOT(deleteCardInfoPopup(QString)));
+
+    if(!bReplay)
+    {
+        connect(messageLog, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
+        connect(messageLog, SIGNAL(addMentionTag(QString)), this, SLOT(addMentionTag(QString)));
+        connect(settingsCache, SIGNAL(chatMentionCompleterChanged()), this, SLOT(actCompleterChanged()));
+
+        timeElapsedLabel = new QLabel;
+        timeElapsedLabel->setAlignment(Qt::AlignCenter);
+        gameTimer = new QTimer(this);
+        gameTimer->setInterval(1000);
+        connect(gameTimer, SIGNAL(timeout()), this, SLOT(incrementGameTime()));
+        gameTimer->start();        
+
+        sayLabel = new QLabel;
+        sayEdit = new LineEditCompleter;
+        sayLabel->setBuddy(sayEdit);
+        completer = new QCompleter(autocompleteUserList, sayEdit);
+        completer->setCaseSensitivity(Qt::CaseInsensitive);
+        completer->setMaxVisibleItems(5);
+
+    #if QT_VERSION >= 0x050000
+        completer->setFilterMode(Qt::MatchStartsWith);
+    #endif
+
+        sayEdit->setCompleter(completer);
+        actCompleterChanged();
+
+        if (spectator && !gameInfo.spectators_can_chat() && tabSupervisor->getAdminLocked()) {
+            sayLabel->hide();
+            sayEdit->hide();
+        }
+        connect(tabSupervisor, SIGNAL(adminLockChanged(bool)), this, SLOT(adminLockChanged(bool)));
+        connect(sayEdit, SIGNAL(returnPressed()), this, SLOT(actSay()));
+
+        sayHLayout = new QHBoxLayout;
+        sayHLayout->addWidget(sayLabel);
+        sayHLayout->addWidget(sayEdit);
+
+    }
+
+    messageLogLayout = new QVBoxLayout;
+    messageLogLayout->setContentsMargins(0, 0, 0, 0);
+    if(!bReplay)
+        messageLogLayout->addWidget(timeElapsedLabel);
+    messageLogLayout->addWidget(messageLog);
+    if(!bReplay)
+        messageLogLayout->addLayout(sayHLayout);
+
+    messageLogLayoutWidget = new QWidget;
+    messageLogLayoutWidget->setLayout(messageLogLayout);
+
+    messageLayoutDock = new QDockWidget(this);
+    messageLayoutDock->setObjectName("messageLayoutDock");
+    messageLayoutDock->setFeatures(QDockWidget::DockWidgetClosable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetMovable);
+    messageLayoutDock->setWidget(messageLogLayoutWidget);
+    messageLayoutDock->setFloating(false);
+
+    messageLayoutDock->installEventFilter(this);  
+    connect(messageLayoutDock, SIGNAL(topLevelChanged(bool)), this, SLOT(dockTopLevelChanged(bool)));
+}
+
+// Method uses to sync docks state with menu items state
+bool TabGame::eventFilter(QObject * o, QEvent * e)
+{
+    if(e->type() == QEvent::Close)
+    {
+        if(o == cardInfoDock)
+        {
+            aCardInfoDockVisible->setChecked(false);
+            aCardInfoDockFloating->setEnabled(false);
+        } else if(o == messageLayoutDock) {
+            aMessageLayoutDockVisible->setChecked(false);
+            aMessageLayoutDockFloating->setEnabled(false);
+        } else if(o == playerListDock) {
+            aPlayerListDockVisible->setChecked(false);
+            aPlayerListDockFloating->setEnabled(false);
+        } else if(o == replayDock) {
+            aReplayDockVisible->setChecked(false);
+            aReplayDockFloating->setEnabled(false);
+        }
+    }   
+
+    return false;
+}
+
+void TabGame::dockVisibleTriggered()
+{
+    QObject *o = sender();
+    if(o == aCardInfoDockVisible)
+    {
+        cardInfoDock->setVisible(aCardInfoDockVisible->isChecked());
+        aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
+        return;
+    }
+
+    if(o == aMessageLayoutDockVisible)
+    {
+        messageLayoutDock->setVisible(aMessageLayoutDockVisible->isChecked());
+        aMessageLayoutDockFloating->setEnabled(aMessageLayoutDockVisible->isChecked());
+        return;
+    }
+
+    if(o == aPlayerListDockVisible)
+    {
+        playerListDock->setVisible(aPlayerListDockVisible->isChecked());
+        aPlayerListDockFloating->setEnabled(aPlayerListDockVisible->isChecked());
+        return;
+    }
+
+    if(o == aReplayDockVisible)
+    {
+        replayDock->setVisible(aReplayDockVisible->isChecked());
+        aReplayDockFloating->setEnabled(aReplayDockVisible->isChecked());
+        return;
+    }
+}
+
+void TabGame::dockFloatingTriggered()
+{
+    QObject *o = sender();
+    if(o == aCardInfoDockFloating)
+    {
+        cardInfoDock->setFloating(aCardInfoDockFloating->isChecked());
+        return;
+    }
+
+    if(o == aMessageLayoutDockFloating)
+    {
+        messageLayoutDock->setFloating(aMessageLayoutDockFloating->isChecked());
+        return;
+    }
+
+    if(o == aPlayerListDockFloating)
+    {
+        playerListDock->setFloating(aPlayerListDockFloating->isChecked());
+        return;
+    }
+
+    if(o == aReplayDockFloating)
+    {
+        replayDock->setFloating(aReplayDockFloating->isChecked());
+        return;
+    }
+}
+
+void TabGame::dockTopLevelChanged(bool topLevel)
+{
+    retranslateUi();
+
+    QObject *o = sender();
+    if(o == cardInfoDock)
+    {
+        aCardInfoDockFloating->setChecked(topLevel);
+        return;
+    }
+
+    if(o == messageLayoutDock)
+    {
+        aMessageLayoutDockFloating->setChecked(topLevel);
+        return;
+    }
+
+    if(o == playerListDock)
+    {
+        aPlayerListDockFloating->setChecked(topLevel);
+        return;
+    }
+
+    if(o == replayDock)
+    {
+        aReplayDockFloating->setChecked(topLevel);
+        return;
+    }
+}

cockatrice/src/tab_game.h

@@ -56,6 +56,8 @@ class GameReplay;
 class ServerInfo_User;
 class PendingCommand;
 class LineEditCompleter;
+class QDockWidget;
+class QStackedWidget;
 
 class ToggleButton : public QPushButton {
     Q_OBJECT
@@ -77,6 +79,7 @@ private:
     QPushButton *loadLocalButton, *loadRemoteButton;
     ToggleButton *readyStartButton, *sideboardLockButton;
     DeckView *deckView;
+    TabGame *parentGame;
     int playerId;
 private slots:
     void loadLocalDeck();
@@ -90,7 +93,7 @@ private slots:
 signals:
     void newCardAdded(AbstractCardItem *card);
 public:
-    DeckViewContainer(int _playerId, TabGame *parent = 0);
+    DeckViewContainer(int _playerId, TabGame *parent);
     void retranslateUi();
     void setButtonsVisible(bool _visible);
     void setReadyStart(bool ready);
@@ -121,6 +124,7 @@ private:
     QStringList gameTypes;
     QCompleter *completer;
     QStringList autocompleteUserList;
+    QStackedWidget * mainWidget;
     
     // Replay related members
     GameReplay *replay;
@@ -128,8 +132,7 @@ private:
     QList<int> replayTimeline;
     ReplayTimelineWidget *timelineWidget;
     QToolButton *replayStartButton, *replayPauseButton, *replayFastForwardButton;
-    
-    QSplitter *splitter;
+
     CardFrame *cardInfo;
     PlayerListWidget *playerListWidget;
     QLabel *timeElapsedLabel;
@@ -140,13 +143,14 @@ private:
     GameScene *scene;
     GameView *gameView;
     QMap<int, DeckViewContainer *> deckViewContainers;
-    QVBoxLayout *deckViewContainerLayout;
-    QHBoxLayout *mainLayout;
-    ZoneViewLayout *zoneLayout;
+    QVBoxLayout *cardVInfoLayout, *messageLogLayout, *gamePlayAreaVBox, *deckViewContainerLayout;
+    QHBoxLayout *cardHInfoLayout, *sayHLayout, *mainHLayout, *replayControlLayout;
+    QWidget *cardBoxLayoutWidget, *messageLogLayoutWidget, *gamePlayAreaWidget, *deckViewContainerWidget, *replayControlWidget;
+    QDockWidget *cardInfoDock, *messageLayoutDock, *playerListDock, *replayDock;
     QAction *playersSeparator;
-    QMenu *gameMenu;
-    QMenu *phasesMenu;
-    QAction *aGameInfo, *aConcede, *aLeaveGame, *aCloseReplay, *aNextPhase, *aNextTurn, *aRemoveLocalArrows, *aRotateViewCW, *aRotateViewCCW;
+    QMenu *gameMenu, *phasesMenu, *viewMenu, *cardInfoDockMenu, *messageLayoutDockMenu, *playerListDockMenu, *replayDockMenu;
+    QAction *aGameInfo, *aConcede, *aLeaveGame, *aCloseReplay, *aNextPhase, *aNextTurn, *aRemoveLocalArrows, *aRotateViewCW, *aRotateViewCCW, *aResetLayout, *aResetReplayLayout;
+    QAction *aCardInfoDockVisible, *aCardInfoDockFloating, *aMessageLayoutDockVisible, *aMessageLayoutDockFloating, *aPlayerListDockVisible, *aPlayerListDockFloating, *aReplayDockVisible, *aReplayDockFloating;
     QList<QAction *> phaseActions;
 
     Player *addPlayer(int playerId, const ServerInfo_User &info);
@@ -171,6 +175,15 @@ private:
     void eventSetActivePhase(const Event_SetActivePhase &event, int eventPlayerId, const GameEventContext &context);
     void eventPing(const Event_Ping &event, int eventPlayerId, const GameEventContext &context);
     void emitUserEvent();
+    void createMenuItems();
+    void createReplayMenuItems();
+    void createViewMenuItems();
+    void createCardInfoDock(bool bReplay=false);
+    void createPlayerListDock(bool bReplay=false);
+    void createMessageDock(bool bReplay=false);
+    void createPlayAreaWidget(bool bReplay=false);
+    void createDeckViewContainerWidget(bool bReplay=false);
+    void createReplayDock();
 signals:
     void gameClosing(TabGame *tab);
     void playerAdded(Player *player);
@@ -207,7 +220,14 @@ private slots:
 	
     void refreshShortcuts();
 	
+    void loadLayout();
 	void actCompleterChanged();
+    void actResetLayout();
+
+    bool eventFilter(QObject *o, QEvent *e);
+    void dockVisibleTriggered();
+    void dockFloatingTriggered();
+    void dockTopLevelChanged(bool topLevel);
 public:
     TabGame(TabSupervisor *_tabSupervisor, QList<AbstractClient *> &_clients, const Event_GameJoined &event, const QMap<int, QString> &_roomGameTypes);
     TabGame(TabSupervisor *_tabSupervisor, GameReplay *replay);