diff --git a/cockatrice/src/settings/layoutssettings.cpp b/cockatrice/src/settings/layoutssettings.cpp
index d81b2bcf..a7d2c749 100644
--- a/cockatrice/src/settings/layoutssettings.cpp
+++ b/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();
+}
diff --git a/cockatrice/src/settings/layoutssettings.h b/cockatrice/src/settings/layoutssettings.h
index 4a42586e..b6282c90 100644
--- a/cockatrice/src/settings/layoutssettings.h
+++ b/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:
diff --git a/cockatrice/src/settingscache.cpp b/cockatrice/src/settingscache.cpp
index dba3b134..9d1f6625 100644
--- a/cockatrice/src/settingscache.cpp
+++ b/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
diff --git a/cockatrice/src/shortcutssettings.cpp b/cockatrice/src/shortcutssettings.cpp
index 36e678c1..fa7be919 100644
--- a/cockatrice/src/shortcutssettings.cpp
+++ b/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("");
 }
diff --git a/cockatrice/src/tab.cpp b/cockatrice/src/tab.cpp
index 7ae2cca2..bf62170d 100644
--- a/cockatrice/src/tab.cpp
+++ b/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)
diff --git a/cockatrice/src/tab.h b/cockatrice/src/tab.h
index 30d4e2ed..3d80e474 100644
--- a/cockatrice/src/tab.h
+++ b/cockatrice/src/tab.h
@@ -1,13 +1,13 @@
 #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);
diff --git a/cockatrice/src/tab_admin.cpp b/cockatrice/src/tab_admin.cpp
index 697644e7..91739f3e 100644
--- a/cockatrice/src/tab_admin.cpp
+++ b/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()
diff --git a/cockatrice/src/tab_deck_editor.cpp b/cockatrice/src/tab_deck_editor.cpp
index 771111a2..736a1297 100644
--- a/cockatrice/src/tab_deck_editor.cpp
+++ b/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());
 
-    btnCard->setChecked(!cardInfoDock->isHidden());
-    btnFilter->setChecked(!filterDock->isHidden());
-    btnDeck->setChecked(!deckDock->isHidden());
+    aCardInfoDockVisible->setChecked(cardInfoDock->isVisible());
+    aFilterDockVisible->setChecked(filterDock->isVisible());
+    aDeckDockVisible->setChecked(deckDock->isVisible());
+
+    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;
+    }
+}
diff --git a/cockatrice/src/tab_deck_editor.h b/cockatrice/src/tab_deck_editor.h
index 996e3ec8..123dee55 100644
--- a/cockatrice/src/tab_deck_editor.h
+++ b/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();
diff --git a/cockatrice/src/tab_deck_storage.cpp b/cockatrice/src/tab_deck_storage.cpp
index 1c0d30d9..90986b12 100644
--- a/cockatrice/src/tab_deck_storage.cpp
+++ b/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()
diff --git a/cockatrice/src/tab_game.cpp b/cockatrice/src/tab_game.cpp
index dd52f64a..0f8d8050 100644
--- a/cockatrice/src/tab_game.cpp
+++ b/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;
+    createCardInfoDock(true);
+    createPlayerListDock(true);
+    createMessageDock(true);
+    createPlayAreaWidget(true);
+    createDeckViewContainerWidget(true);
+    createReplayDock();
 
-    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);
+    addDockWidget(Qt::RightDockWidgetArea, cardInfoDock);
+    addDockWidget(Qt::RightDockWidgetArea, playerListDock);
+    addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
+    addDockWidget(Qt::BottomDockWidgetArea, replayDock);
 
-    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);
-    
+    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;
+    createCardInfoDock();
+    createPlayerListDock();
+    createMessageDock();
+    createPlayAreaWidget();
+    createDeckViewContainerWidget();
 
-    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);
+    addDockWidget(Qt::RightDockWidgetArea, cardInfoDock);
+    addDockWidget(Qt::RightDockWidgetArea, playerListDock);
+    addDockWidget(Qt::RightDockWidgetArea, messageLayoutDock);
 
-    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()));
+    mainWidget = new QStackedWidget(this);
+    mainWidget->addWidget(deckViewContainerWidget);
+    mainWidget->addWidget(gamePlayAreaWidget);
+    setCentralWidget(mainWidget);
 
-    // 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);
-    }
-
-    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);
-    
+    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;
+    }
+}
diff --git a/cockatrice/src/tab_game.h b/cockatrice/src/tab_game.h
index 5b13ffdd..bed00b04 100644
--- a/cockatrice/src/tab_game.h
+++ b/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);
diff --git a/cockatrice/src/tab_logs.cpp b/cockatrice/src/tab_logs.cpp
index bd4a32e2..f1b6563a 100644
--- a/cockatrice/src/tab_logs.cpp
+++ b/cockatrice/src/tab_logs.cpp
@@ -8,6 +8,7 @@
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QRadioButton>
+#include <QTabWidget>
 #include "tab_logs.h"
 #include "abstractclient.h"
 #include "window_sets.h"
@@ -23,7 +24,27 @@
 TabLog::TabLog(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWidget *parent)
     : Tab(_tabSupervisor, parent), client(_client)
 {
-    MainWindow = new QMainWindow;
+    roomTable = new QTableWidget();
+    roomTable->setColumnCount(6);
+    roomTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    roomTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
+
+    gameTable = new QTableWidget();
+    gameTable->setColumnCount(6);
+    gameTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    gameTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
+
+    chatTable = new QTableWidget();
+    chatTable->setColumnCount(6);
+    chatTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    chatTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
+
+    QTabWidget *tabManager = new QTabWidget();
+    tabManager->addTab(roomTable, tr("Room Logs"));
+    tabManager->addTab(gameTable, tr("Game Logs"));
+    tabManager->addTab(chatTable, tr("Chat Logs"));
+    setCentralWidget(tabManager);
+
     createDock();
     restartLayout();
     clearClicked();
@@ -212,7 +233,7 @@ void TabLog::createDock()
     buttonGroupBox = new QGroupBox(tr(""));
     buttonGroupBox->setLayout(buttonGrid);
 
-    mainLayout = new QVBoxLayout(MainWindow);
+    mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(criteriaGroupBox);
     mainLayout->addWidget(locationGroupBox);
     mainLayout->addWidget(rangeGroupBox);
@@ -221,116 +242,94 @@ void TabLog::createDock()
     mainLayout->addWidget(buttonGroupBox);
     mainLayout->setAlignment(Qt::AlignCenter);
 
-    searchDockContents = new QWidget(MainWindow);
+    searchDockContents = new QWidget(this);
     searchDockContents->setLayout(mainLayout);
 
-    searchDock = new QDockWidget(MainWindow);
+    searchDock = new QDockWidget(this);
     searchDock->setFeatures(QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetMovable);
     searchDock->setWidget(searchDockContents);
-
-    QVBoxLayout *mainVLayoutContent = new QVBoxLayout;
-    QHBoxLayout *mainHLayoutContent = new QHBoxLayout;
-    mainHLayoutContent->addWidget(MainWindow);
-    mainHLayoutContent->addLayout(mainVLayoutContent);
-    setLayout(mainHLayoutContent);
 }
 
 void TabLog::viewLogHistory_processResponse(const Response &resp)
 {
     const Response_ViewLogHistory &response = resp.GetExtension(Response_ViewLogHistory::ext);
-    if (resp.response_code() == Response::RespOk) {
-
-        if (response.log_message_size() > 0) {
-
-            int j = 0;
-            QTableWidget *roomTable = new QTableWidget();
-            roomTable->setWindowTitle(tr("Room Logs"));
-            roomTable->setRowCount(response.log_message_size());
-            roomTable->setColumnCount(6);
-            roomTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-            roomTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
-
-            int k = 0;
-            QTableWidget *gameTable = new QTableWidget();
-            gameTable->setWindowTitle(tr("Game Logs"));
-            gameTable->setRowCount(response.log_message_size());
-            gameTable->setColumnCount(6);
-            gameTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-            gameTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
-
-            int l = 0;
-            QTableWidget *chatTable = new QTableWidget();
-            chatTable->setWindowTitle(tr("Chat Logs"));
-            chatTable->setRowCount(response.log_message_size());
-            chatTable->setColumnCount(6);
-            chatTable->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-            chatTable->setHorizontalHeaderLabels(QString(tr("Time;SenderName;SenderIP;Message;TargetID;TargetName")).split(";"));
-
-            ServerInfo_ChatMessage message; for (int i = 0; i < response.log_message_size(); ++i) {
-                message = response.log_message(i);
-                if (QString::fromStdString(message.target_type()) == "room") {
-                    roomTable->setItem(j, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
-                    roomTable->setItem(j, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
-                    roomTable->setItem(j, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
-                    roomTable->setItem(j, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
-                    roomTable->setItem(j, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
-                    roomTable->setItem(j, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
-                    ++j;
-                }
-
-                if (QString::fromStdString(message.target_type()) == "game") {
-                    gameTable->setItem(k, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
-                    gameTable->setItem(k, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
-                    gameTable->setItem(k, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
-                    gameTable->setItem(k, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
-                    gameTable->setItem(k, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
-                    gameTable->setItem(k, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
-                    ++k;
-                }
-
-                if (QString::fromStdString(message.target_type()) == "chat") {
-                    chatTable->setItem(l, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
-                    chatTable->setItem(l, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
-                    chatTable->setItem(l, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
-                    chatTable->setItem(l, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
-                    chatTable->setItem(l, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
-                    chatTable->setItem(l, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
-                    ++l;
-                }
-            }
-
-            roomTable->setRowCount(j);
-            roomTable->resizeColumnsToContents();
-            gameTable->setRowCount(k);
-            gameTable->resizeColumnsToContents();
-            chatTable->setRowCount(l);
-            chatTable->resizeColumnsToContents();
-
-            if (mainRoom->isChecked()) {
-                roomTable->resize(600, 200);
-                roomTable->show();
-            }
-
-            if (gameRoom->isChecked()) {
-                gameTable->resize(600, 200);
-                gameTable->show();
-            }
-
-            if (privateChat->isChecked()) {
-                chatTable->resize(600, 200);
-                chatTable->show();
-            }
-
-        } else
-            QMessageBox::information(static_cast<QWidget *>(parent()), tr("Message History"), tr("There are no messages for the selected filters."));
-
-    } else
+    if (resp.response_code() != Response::RespOk) {
         QMessageBox::critical(static_cast<QWidget *>(parent()), tr("Message History"), tr("Failed to collect message history information."));
+        return;
+    }
+
+    if (response.log_message_size() == 0) {
+        QMessageBox::information(static_cast<QWidget *>(parent()), tr("Message History"), tr("There are no messages for the selected filters."));
+        return;
+    }
+
+    int roomCounter = 0, gameCounter = 0, chatCounter = 0;
+    roomTable->setRowCount(roomCounter);
+    gameTable->setRowCount(gameCounter);
+    chatTable->setRowCount(chatCounter);
+
+    for (int i = 0; i < response.log_message_size(); ++i)
+    {
+        ServerInfo_ChatMessage message = response.log_message(i);
+        if (QString::fromStdString(message.target_type()) == "room") {
+            roomTable->insertRow(roomCounter);
+            roomTable->setItem(roomCounter, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
+            roomTable->setItem(roomCounter, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
+            roomTable->setItem(roomCounter, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
+            roomTable->setItem(roomCounter, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
+            roomTable->setItem(roomCounter, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
+            roomTable->setItem(roomCounter, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
+            ++roomCounter;
+        }
+
+        if (QString::fromStdString(message.target_type()) == "game") {
+            gameTable->insertRow(gameCounter);
+            gameTable->setItem(gameCounter, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
+            gameTable->setItem(gameCounter, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
+            gameTable->setItem(gameCounter, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
+            gameTable->setItem(gameCounter, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
+            gameTable->setItem(gameCounter, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
+            gameTable->setItem(gameCounter, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
+            ++gameCounter;
+        }
+
+        if (QString::fromStdString(message.target_type()) == "chat") {
+            chatTable->insertRow(chatCounter);
+            chatTable->setItem(chatCounter, 0, new QTableWidgetItem(QString::fromStdString(message.time())));
+            chatTable->setItem(chatCounter, 1, new QTableWidgetItem(QString::fromStdString(message.sender_name())));
+            chatTable->setItem(chatCounter, 2, new QTableWidgetItem(QString::fromStdString(message.sender_ip())));
+            chatTable->setItem(chatCounter, 3, new QTableWidgetItem(QString::fromStdString(message.message())));
+            chatTable->setItem(chatCounter, 4, new QTableWidgetItem(QString::fromStdString(message.target_id())));
+            chatTable->setItem(chatCounter, 5, new QTableWidgetItem(QString::fromStdString(message.target_name())));
+            ++chatCounter;
+        }
+    }
+
+    if (roomCounter) {
+        roomTable->show();
+        roomTable->resizeColumnsToContents();
+    } else {
+        roomTable->hide();
+    }
+
+    if (gameCounter) {
+        gameTable->resizeColumnsToContents();
+        gameTable->show();
+    } else {
+        gameTable->hide();
+    }
+
+    if (chatCounter) {
+        chatTable->resizeColumnsToContents();
+        chatTable->show();
+    } else {
+        chatTable->hide();
+    }
 }
 
 void TabLog::restartLayout()
 {
     searchDock->setFloating(false);
-    MainWindow->addDockWidget(Qt::TopDockWidgetArea, searchDock);
+    addDockWidget(Qt::LeftDockWidgetArea, searchDock);
     searchDock->setVisible(true);
 }
\ No newline at end of file
diff --git a/cockatrice/src/tab_logs.h b/cockatrice/src/tab_logs.h
index ab848c66..c6b0cfdb 100644
--- a/cockatrice/src/tab_logs.h
+++ b/cockatrice/src/tab_logs.h
@@ -16,10 +16,10 @@ class QLabel;
 class QDockWidget;
 class QWidget;
 class QGridLayout;
+class QTableWidget;
 class CommandContainer;
 class Response;
 class AbstractClient;
-class QMainWindow;
 
 class TabLog : public Tab {
     Q_OBJECT
@@ -36,7 +36,7 @@ private:
     QGridLayout *criteriaGrid, *locationGrid, *rangeGrid, *maxResultsGrid, *descriptionGrid, *buttonGrid;
     QGroupBox *criteriaGroupBox, *locationGroupBox, *rangeGroupBox, *maxResultsGroupBox, *descriptionGroupBox, *buttonGroupBox;
     QVBoxLayout *mainLayout;
-    QMainWindow *MainWindow;
+    QTableWidget *roomTable, *gameTable, *chatTable;
 
     void createDock();
 signals:
diff --git a/cockatrice/src/tab_message.cpp b/cockatrice/src/tab_message.cpp
index df56ce9e..c9f4e625 100644
--- a/cockatrice/src/tab_message.cpp
+++ b/cockatrice/src/tab_message.cpp
@@ -39,7 +39,10 @@ TabMessage::TabMessage(TabSupervisor *_tabSupervisor, AbstractClient *_client, c
     addTabMenu(messageMenu);
 
     retranslateUi();
-    setLayout(vbox);
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(vbox);
+    setCentralWidget(mainWidget);
 }
 
 TabMessage::~TabMessage()
diff --git a/cockatrice/src/tab_replays.cpp b/cockatrice/src/tab_replays.cpp
index 515b7d82..0860a5ea 100644
--- a/cockatrice/src/tab_replays.cpp
+++ b/cockatrice/src/tab_replays.cpp
@@ -106,7 +106,10 @@ TabReplays::TabReplays(TabSupervisor *_tabSupervisor, AbstractClient *_client)
     rightToolBar->addAction(aDeleteRemoteReplay);
     
     retranslateUi();
-    setLayout(hbox);
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(hbox);
+    setCentralWidget(mainWidget);
     
     connect(client, SIGNAL(replayAddedEventReceived(const Event_ReplayAdded &)), this, SLOT(replayAddedEventReceived(const Event_ReplayAdded &)));
 }
diff --git a/cockatrice/src/tab_room.cpp b/cockatrice/src/tab_room.cpp
index 5f6143c3..ba59a2aa 100644
--- a/cockatrice/src/tab_room.cpp
+++ b/cockatrice/src/tab_room.cpp
@@ -104,9 +104,6 @@ TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, ServerI
     roomMenu->addAction(aLeaveRoom);
     addTabMenu(roomMenu);
 
-    retranslateUi();
-    setLayout(hbox);
-
     const int userListSize = info.user_list_size();
     for (int i = 0; i < userListSize; ++i){
         userList->processUserInfo(info.user_list(i), true);
@@ -130,6 +127,12 @@ TabRoom::TabRoom(TabSupervisor *_tabSupervisor, AbstractClient *_client, ServerI
     actCompleterChanged();
     connect(&settingsCache->shortcuts(), SIGNAL(shortCutchanged()),this,SLOT(refreshShortcuts()));
     refreshShortcuts();
+
+    retranslateUi();
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(hbox);
+    setCentralWidget(mainWidget);
 }
 
 TabRoom::~TabRoom()
diff --git a/cockatrice/src/tab_server.cpp b/cockatrice/src/tab_server.cpp
index 36e1b42d..0abd12c5 100644
--- a/cockatrice/src/tab_server.cpp
+++ b/cockatrice/src/tab_server.cpp
@@ -140,8 +140,12 @@ TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWi
     QVBoxLayout *vbox = new QVBoxLayout;
     vbox->addWidget(roomSelector);
     vbox->addWidget(serverInfoBox);
-    
-    setLayout(vbox);
+ 
+    retranslateUi();
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(vbox);
+    setCentralWidget(mainWidget);
 }
 
 void TabServer::retranslateUi()
diff --git a/cockatrice/src/tab_userlists.cpp b/cockatrice/src/tab_userlists.cpp
index d5f57d1e..0728ab97 100644
--- a/cockatrice/src/tab_userlists.cpp
+++ b/cockatrice/src/tab_userlists.cpp
@@ -75,7 +75,11 @@ TabUserLists::TabUserLists(TabSupervisor *_tabSupervisor, AbstractClient *_clien
     mainLayout->addLayout(ignorePanel);
     mainLayout->addLayout(vbox);
 
-    setLayout(mainLayout);
+    retranslateUi();
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(mainLayout);
+    setCentralWidget(mainWidget);
 }
 
 void TabUserLists::addToBuddyList()