Merge pull request #1753 from ctrlaltca/pr_1544

Re-Dockified the game & replay review areas

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/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/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);
+
+    aCardInfoDockFloating->setChecked(false);
+    aDeckDockFloating->setChecked(false);
+    aFilterDockFloating->setChecked(false);
 
-    MainWindow->splitDockWidget(cardInfoDock, deckDock, Qt::Horizontal);
-    MainWindow->splitDockWidget(cardInfoDock, filterDock, Qt::Vertical);
+    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());
+
+    aCardInfoDockFloating->setEnabled(aCardInfoDockVisible->isChecked());
+    aDeckDockFloating->setEnabled(aDeckDockVisible->isChecked());
+    aFilterDockFloating->setEnabled(aFilterDockVisible->isChecked());
 
-    btnCard->setChecked(!cardInfoDock->isHidden());
-    btnFilter->setChecked(!filterDock->isHidden());
-    btnDeck->setChecked(!deckDock->isHidden());
+    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.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;
@@ -129,7 +133,6 @@ private:
     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);

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(";"));
+    if (resp.response_code() != Response::RespOk) {
+        QMessageBox::critical(static_cast<QWidget *>(parent()), tr("Message History"), tr("Failed to collect message history information."));
+        return;
+    }
 
-            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(";"));
+    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 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(";"));
+    int roomCounter = 0, gameCounter = 0, chatCounter = 0;
+    roomTable->setRowCount(roomCounter);
+    gameTable->setRowCount(gameCounter);
+    chatTable->setRowCount(chatCounter);
 
-            ServerInfo_ChatMessage message; for (int i = 0; i < response.log_message_size(); ++i) {
-                message = response.log_message(i);
+    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->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;
+            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->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;
+            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->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;
+            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;
         }
     }
 
-            roomTable->setRowCount(j);
-            roomTable->resizeColumnsToContents();
-            gameTable->setRowCount(k);
-            gameTable->resizeColumnsToContents();
-            chatTable->setRowCount(l);
-            chatTable->resizeColumnsToContents();
-
-            if (mainRoom->isChecked()) {
-                roomTable->resize(600, 200);
+    if (roomCounter) {
         roomTable->show();
+        roomTable->resizeColumnsToContents();
+    } else {
+        roomTable->hide();
     }
 
-            if (gameRoom->isChecked()) {
-                gameTable->resize(600, 200);
+    if (gameCounter) {
+        gameTable->resizeColumnsToContents();
         gameTable->show();
+    } else {
+        gameTable->hide();
     }
 
-            if (privateChat->isChecked()) {
-                chatTable->resize(600, 200);
+    if (chatCounter) {
+        chatTable->resizeColumnsToContents();
         chatTable->show();
+    } else {
+        chatTable->hide();
     }
-
-        } else
-            QMessageBox::information(static_cast<QWidget *>(parent()), tr("Message History"), tr("There are no messages for the selected filters."));
-
-    } else
-        QMessageBox::critical(static_cast<QWidget *>(parent()), tr("Message History"), tr("Failed to collect message history information."));
 }
 
 void TabLog::restartLayout()
 {
     searchDock->setFloating(false);
-    MainWindow->addDockWidget(Qt::TopDockWidgetArea, searchDock);
+    addDockWidget(Qt::LeftDockWidgetArea, searchDock);
     searchDock->setVisible(true);
 }
\ No newline at end of file

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:

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()

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 &)));
 }

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()

cockatrice/src/tab_server.cpp

@@ -141,7 +141,11 @@ TabServer::TabServer(TabSupervisor *_tabSupervisor, AbstractClient *_client, QWi
     vbox->addWidget(roomSelector);
     vbox->addWidget(serverInfoBox);
  
-    setLayout(vbox);
+    retranslateUi();
+
+    QWidget * mainWidget = new QWidget(this);
+    mainWidget->setLayout(vbox);
+    setCentralWidget(mainWidget);
 }
 
 void TabServer::retranslateUi()

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()