Dont use guichan tab and tabbedarea anymore.

It have some methods and widget connections what cant be
changed by overloading.

5 files changed, 306 insertions, 35 deletions

diff --git a/src/gui/widgets/chattab.cpp b/src/gui/widgets/chattab.cpp
index d71f7f640..a0b31d040 100644
--- a/src/gui/widgets/chattab.cpp
+++ b/src/gui/widgets/chattab.cpp
@@ -34,6 +34,7 @@
 
 #include "gui/widgets/scrollarea.h"
 #include "gui/widgets/itemlinkhandler.h"
+#include "gui/widgets/tabbedarea.h"
 #include "gui/widgets/tradetab.h"
 
 #include "net/chathandler.h"
@@ -44,8 +45,6 @@
 
 #include "utils/gettext.h"
 
-#include <guichan/widgets/tabbedarea.hpp>
-
 #include "debug.h"
 
 static const unsigned int MAX_WORD_SIZE = 50;
diff --git a/src/gui/widgets/tab.cpp b/src/gui/widgets/tab.cpp
index e002c03fe..ab7d5683e 100644
--- a/src/gui/widgets/tab.cpp
+++ b/src/gui/widgets/tab.cpp
@@ -31,6 +31,7 @@
 #include "gui/palette.h"
 #include "gui/theme.h"
 
+#include "gui/widgets/label.h"
 #include "gui/widgets/tabbedarea.h"
 
 #include "utils/dtor.h"
@@ -62,8 +63,14 @@ static std::string const data[TAB_COUNT] =
 ImageRect Tab::tabImg[TAB_COUNT];
 
 Tab::Tab() :
-    gcn::Tab(),
+    gcn::BasicContainer(),
+    gcn::MouseListener(),
     gcn::WidgetListener(),
+
+    mLabel(new Label),
+    mHasMouse(false),
+    mTabbedArea(nullptr),
+
     mTabColor(&Theme::getThemeColor(Theme::TAB)),
     mTabHighlightedColor(&Theme::getThemeColor(Theme::TAB_HIGHLIGHTED)),
     mTabSelectedColor(&Theme::getThemeColor(Theme::TAB_SELECTED)),
@@ -85,12 +92,20 @@ Tab::~Tab()
         for (int mode = 0; mode < TAB_COUNT; mode ++)
             theme->unloadRect(tabImg[mode]);
     }
+
+    delete mLabel;
+    mLabel = nullptr;
+
     delete mVertexes;
     mVertexes = nullptr;
 }
 
 void Tab::init()
 {
+    mLabel->setPosition(4, 4);
+    add(mLabel);
+
+    addMouseListener(this);
     setFocusable(false);
     setFrameSize(0);
     mFlash = 0;
@@ -209,3 +224,45 @@ void Tab::setLabelFont(gcn::Font *const font)
     mLabel->adjustSize();
     adjustSize();
 }
+
+
+void Tab::adjustSize()
+{
+    setSize(mLabel->getWidth() + 8,
+            mLabel->getHeight() + 8);
+
+    if (mTabbedArea)
+        mTabbedArea->adjustTabPositions();
+}
+
+void Tab::setTabbedArea(TabbedArea* tabbedArea)
+{
+    mTabbedArea = tabbedArea;
+}
+
+TabbedArea* Tab::getTabbedArea()
+{
+    return mTabbedArea;
+}
+
+void Tab::setCaption(const std::string &caption)
+{
+    mLabel->setCaption(caption);
+    mLabel->adjustSize();
+    adjustSize();
+}
+
+const std::string &Tab::getCaption() const
+{
+    return mLabel->getCaption();
+}
+
+void Tab::mouseEntered(gcn::MouseEvent& mouseEvent A_UNUSED)
+{
+    mHasMouse = true;
+}
+
+void Tab::mouseExited(gcn::MouseEvent& mouseEvent A_UNUSED)
+{
+    mHasMouse = false;
+}
diff --git a/src/gui/widgets/tab.h b/src/gui/widgets/tab.h
index 28ae9f392..8c6e7d115 100644
--- a/src/gui/widgets/tab.h
+++ b/src/gui/widgets/tab.h
@@ -23,19 +23,25 @@
 #ifndef TAB_H
 #define TAB_H
 
+#include <guichan/basiccontainer.hpp>
+#include <guichan/mouselistener.hpp>
+
 #include <guichan/widgets/label.hpp>
-#include <guichan/widgets/tab.hpp>
+
 #include <guichan/widgetlistener.hpp>
 
 class GraphicsVertexes;
 class ImageRect;
+class Label;
 class TabbedArea;
 
 /**
  * A tab, the same as the Guichan tab in 0.8, but extended to allow
  * transparency.
  */
-class Tab : public gcn::Tab, public gcn::WidgetListener
+class Tab : public gcn::BasicContainer,
+            public gcn::MouseListener,
+            public gcn::WidgetListener
 {
     public:
         Tab();
@@ -99,15 +105,35 @@ class Tab : public gcn::Tab, public gcn::WidgetListener
 
         void setLabelFont(gcn::Font *const font);
 
-        gcn::Label *getLabel() const
+        Label *getLabel() const
         { return mLabel; }
 
+        void adjustSize();
+
+        void setTabbedArea(TabbedArea* tabbedArea);
+
+        TabbedArea* getTabbedArea();
+
+        void setCaption(const std::string& caption);
+
+        const std::string &getCaption() const;
+
+        void mouseEntered(gcn::MouseEvent &mouseEvent) override;
+
+        void mouseExited(gcn::MouseEvent &mouseEvent) override;
+
     protected:
         friend class TabbedArea;
 
         virtual void setCurrent()
         { }
 
+        Label* mLabel;
+
+        bool mHasMouse;
+
+        TabbedArea* mTabbedArea;
+
     private:
         /** Load images if no other instances exist yet */
         void init();
diff --git a/src/gui/widgets/tabbedarea.cpp b/src/gui/widgets/tabbedarea.cpp
index 1cc990f21..7643e0044 100644
--- a/src/gui/widgets/tabbedarea.cpp
+++ b/src/gui/widgets/tabbedarea.cpp
@@ -35,8 +35,17 @@
 #include "debug.h"
 
 TabbedArea::TabbedArea() :
-    gcn::TabbedArea(),
+    gcn::ActionListener(),
+    gcn::BasicContainer(),
+    gcn::KeyListener(),
+    gcn::MouseListener(),
     gcn::WidgetListener(),
+
+    mSelectedTab(nullptr),
+    mTabContainer(new gcn::Container()),
+    mWidgetContainer(new gcn::Container()),
+    mOpaque(false),
+
     mTabsWidth(0),
     mVisibleTabsWidth(0),
     mTabScrollIndex(0),
@@ -45,6 +54,16 @@ TabbedArea::TabbedArea() :
     mFollowDownScroll(false),
     mBlockSwitching(true)
 {
+    setFocusable(true);
+    addKeyListener(this);
+    addMouseListener(this);
+    mTabContainer->setOpaque(false);
+
+    add(mTabContainer);
+    add(mWidgetContainer);
+
+
+
     mWidgetContainer->setOpaque(false);
     addWidgetListener(this);
 
@@ -56,6 +75,20 @@ TabbedArea::TabbedArea() :
 
 TabbedArea::~TabbedArea()
 {
+    remove(mTabContainer);
+    remove(mWidgetContainer);
+
+    delete mTabContainer;
+    mTabContainer = nullptr;
+    delete mWidgetContainer;
+    mWidgetContainer = nullptr;
+
+    for (size_t i = 0, sz = mTabsToDelete.size(); i < sz; i++)
+    {
+        delete mTabsToDelete[i];
+        mTabsToDelete[i] = nullptr;
+    }
+
     delete mArrowButton[0];
     mArrowButton[0] = nullptr;
     delete mArrowButton[1];
@@ -124,7 +157,7 @@ gcn::Widget *TabbedArea::getWidget(const std::string &name) const
 
 gcn::Widget *TabbedArea::getCurrentWidget()
 {
-    const gcn::Tab *const tab = getSelectedTab();
+    const Tab *const tab = getSelectedTab();
 
     if (tab)
         return getWidget(tab->getCaption());
@@ -132,12 +165,25 @@ gcn::Widget *TabbedArea::getCurrentWidget()
         return nullptr;
 }
 
-void TabbedArea::addTab(gcn::Tab* tab, gcn::Widget* widget)
+void TabbedArea::addTab(Tab* tab, gcn::Widget* widget)
 {
     if (!tab || !widget)
         return;
 
-    gcn::TabbedArea::addTab(tab, widget);
+
+    tab->setTabbedArea(this);
+    tab->addActionListener(this);
+
+    mTabContainer->add(tab);
+    mTabs.push_back(std::pair<Tab*, gcn::Widget*>(tab, widget));
+
+    if (!mSelectedTab)
+        setSelectedTab(tab);
+
+    adjustTabPositions();
+    adjustSize();
+
+
 
     const int frameSize = 2 * getFrameSize();
     widget->setSize(getWidth() - frameSize,
@@ -156,7 +202,28 @@ void TabbedArea::addTab(const std::string &caption, gcn::Widget *const widget)
     addTab(tab, widget);
 }
 
-void TabbedArea::removeTab(gcn::Tab *tab)
+bool TabbedArea::isTabSelected(unsigned int index) const
+{
+    if (index >= mTabs.size())
+        return false;
+
+    return mSelectedTab == mTabs[index].first;
+}
+
+bool TabbedArea::isTabSelected(Tab* tab)
+{
+    return mSelectedTab == tab;
+}
+
+void TabbedArea::setSelectedTab(unsigned int index)
+{
+    if (index >= mTabs.size())
+        return;
+
+    setSelectedTab(mTabs[index].first);
+}
+
+void TabbedArea::removeTab(Tab *tab)
 {
     int tabIndexToBeSelected = -1;
 
@@ -181,7 +248,7 @@ void TabbedArea::removeTab(gcn::Tab *tab)
         }
     }
 
-    for (std::vector<gcn::Tab*>::iterator iter2 = mTabsToDelete.begin();
+    for (std::vector<Tab*>::iterator iter2 = mTabsToDelete.begin();
          iter2 != mTabsToDelete.end(); ++iter2)
     {
         if (*iter2 == tab)
@@ -227,7 +294,7 @@ void TabbedArea::mousePressed(gcn::MouseEvent &mouseEvent)
     {
         gcn::Widget *const widget = mTabContainer->getWidgetAt(
             mouseEvent.getX(), mouseEvent.getY());
-        gcn::Tab *const tab = dynamic_cast<gcn::Tab *const>(widget);
+        Tab *const tab = dynamic_cast<Tab *const>(widget);
 
         if (tab)
         {
@@ -237,9 +304,23 @@ void TabbedArea::mousePressed(gcn::MouseEvent &mouseEvent)
     }
 }
 
-void TabbedArea::setSelectedTab(gcn::Tab *tab)
+void TabbedArea::setSelectedTab(Tab *tab)
 {
-    gcn::TabbedArea::setSelectedTab(tab);
+    unsigned int i;
+    for (i = 0; i < mTabs.size(); i++)
+    {
+        if (mTabs[i].first == mSelectedTab)
+            mWidgetContainer->remove(mTabs[i].second);
+    }
+
+    for (i = 0; i < mTabs.size(); i++)
+    {
+        if (mTabs[i].first == tab)
+        {
+            mSelectedTab = tab;
+            mWidgetContainer->add(mTabs[i].second);
+        }
+    }
 
     Tab *const newTab = dynamic_cast<Tab *const>(tab);
 
@@ -249,6 +330,18 @@ void TabbedArea::setSelectedTab(gcn::Tab *tab)
     widgetResized(nullptr);
 }
 
+int TabbedArea::getSelectedTabIndex() const
+{
+    for (unsigned int i = 0, sz = static_cast<unsigned int>(mTabs.size());
+         i < sz; i++)
+    {
+        if (mTabs[i].first == mSelectedTab)
+            return i;
+    }
+
+    return -1;
+}
+
 void TabbedArea::setSelectedTabByName(const std::string &name)
 {
     for (TabContainer::const_iterator itr = mTabs.begin(),
@@ -264,7 +357,7 @@ void TabbedArea::setSelectedTabByName(const std::string &name)
 
 void TabbedArea::setSelectedTabByPos(int tab)
 {
-    gcn::TabbedArea::setSelectedTab(tab);
+    setSelectedTab(tab);
 }
 
 void TabbedArea::widgetResized(const gcn::Event &event A_UNUSED)
@@ -354,13 +447,30 @@ void TabbedArea::updateVisibleTabsWidth()
     }
 }
 
+void TabbedArea::adjustSize()
+{
+    int maxTabHeight = 0;
+
+    for (size_t i = 0, sz = mTabs.size(); i < sz; i++)
+    {
+        if (mTabs[i].first->getHeight() > maxTabHeight)
+            maxTabHeight = mTabs[i].first->getHeight();
+    }
+
+    mTabContainer->setSize(getWidth() - 2, maxTabHeight);
+
+    mWidgetContainer->setPosition(1, maxTabHeight + 1);
+    mWidgetContainer->setSize(getWidth() - 2,
+        getHeight() - maxTabHeight - 2);
+}
+
 void TabbedArea::adjustTabPositions()
 {
     int maxTabHeight = 0;
     const size_t sz = mTabs.size();
     for (size_t i = 0; i < sz; ++i)
     {
-        const gcn::Tab *const tab = mTabs[i].first;
+        const Tab *const tab = mTabs[i].first;
         if (tab && tab->getHeight() > maxTabHeight)
             maxTabHeight = tab->getHeight();
     }
@@ -368,7 +478,7 @@ void TabbedArea::adjustTabPositions()
     int x = mArrowButton[0]->isVisible() ? mArrowButton[0]->getWidth() : 0;
     for (size_t i = mTabScrollIndex; i < sz; ++i)
     {
-        gcn::Tab *const tab = mTabs[i].first;
+        Tab *const tab = mTabs[i].first;
         if (!tab)
             continue;
         tab->setPosition(x, maxTabHeight - tab->getHeight());
@@ -381,7 +491,7 @@ void TabbedArea::adjustTabPositions()
         x = 0;
         for (unsigned i = 0; i < mTabScrollIndex; ++i)
         {
-            gcn::Tab *const tab = mTabs[i].first;
+            Tab *const tab = mTabs[i].first;
             if (tab)
             {
                 x -= tab->getWidth();
@@ -480,7 +590,7 @@ void TabbedArea::removeAll()
     while (getNumberOfTabs() > 0)
     {
         const int idx = getNumberOfTabs() - 1;
-        gcn::Tab *tab = mTabs[idx].first;
+        Tab *tab = mTabs[idx].first;
         Widget *widget = mTabs[idx].second;
         removeTab(tab);
         delete tab;
@@ -488,6 +598,30 @@ void TabbedArea::removeAll()
     }
 }
 
+void TabbedArea::setWidth(int width)
+{
+    gcn::Widget::setWidth(width);
+    adjustSize();
+}
+
+void TabbedArea::setHeight(int height)
+{
+    gcn::Widget::setHeight(height);
+    adjustSize();
+}
+
+void TabbedArea::setSize(int width, int height)
+{
+    gcn::Widget::setSize(width, height);
+    adjustSize();
+}
+
+void TabbedArea::setDimension(const gcn::Rectangle &dimension)
+{
+    gcn::Widget::setDimension(dimension);
+    adjustSize();
+}
+
 void TabbedArea::keyPressed(gcn::KeyEvent& keyEvent)
 {
     if (mBlockSwitching || keyEvent.isConsumed() || !isFocused())
@@ -520,3 +654,13 @@ void TabbedArea::keyPressed(gcn::KeyEvent& keyEvent)
         keyEvent.consume();
     }
 }
+
+void TabbedArea::death(const gcn::Event &event)
+{
+    Tab *const tab = dynamic_cast<Tab*>(event.getSource());
+
+    if (tab)
+        removeTab(tab);
+    else
+        gcn::BasicContainer::death(event);
+}
diff --git a/src/gui/widgets/tabbedarea.h b/src/gui/widgets/tabbedarea.h
index 9edf46748..b7e5f8154 100644
--- a/src/gui/widgets/tabbedarea.h
+++ b/src/gui/widgets/tabbedarea.h
@@ -23,10 +23,10 @@
 #ifndef TABBEDAREA_H
 #define TABBEDAREA_H
 
+#include <guichan/actionlistener.hpp>
 #include <guichan/widget.hpp>
 #include <guichan/widgetlistener.hpp>
 #include <guichan/widgets/container.hpp>
-#include <guichan/widgets/tabbedarea.hpp>
 
 #include "gui/widgets/button.h"
 
@@ -37,7 +37,11 @@ class Tab;
 /**
  * A tabbed area, the same as the guichan tabbed area in 0.8, but extended
  */
-class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
+class TabbedArea final : public gcn::ActionListener,
+                         public gcn::BasicContainer,
+                         public gcn::KeyListener,
+                         public gcn::MouseListener,
+                         public gcn::WidgetListener
 {
     public:
         /**
@@ -86,21 +90,18 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
          * @param tab The tab widget for the tab.
          * @param widget The widget to view when the tab is selected.
          */
-        void addTab(gcn::Tab* tab, gcn::Widget* widget) override;
+        void addTab(Tab *tab, gcn::Widget *widget);
 
-        /**
-         * Add a tab. Overridden since it needs to create an instance of Tab
-         * instead of gcn::Tab.
-         *
-         * @param caption The Caption to display
-         * @param widget The widget to show when tab is selected
-         */
         void addTab(const std::string &caption, gcn::Widget *const widget);
 
+        bool isTabSelected(unsigned int index) const;
+
+        bool isTabSelected(Tab* tab);
+
         /**
          * Overload the remove tab function as it's broken in guichan 0.8.
          */
-        void removeTab(gcn::Tab *tab) override;
+        void removeTab(Tab *tab);
 
         void removeAll();
 
@@ -112,7 +113,22 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
         int getContainerHeight() const
         { return mWidgetContainer->getHeight(); }
 
-        void setSelectedTab(gcn::Tab *tab) override;
+        void setSelectedTab(Tab *tab);
+
+        void setSelectedTab(unsigned int index);
+
+        int getSelectedTabIndex() const;
+
+        Tab* getSelectedTab()
+        { return mSelectedTab; }
+
+        void setOpaque(bool opaque)
+        { mOpaque = opaque; }
+
+        bool isOpaque() const
+        { return mOpaque; }
+
+        void adjustSize();
 
         void setSelectedTabByPos(int tab);
 
@@ -121,9 +137,9 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
         void widgetResized(const gcn::Event &event) override;
 
 /*
-        void moveLeft(gcn::Tab *tab);
+        void moveLeft(Tab *tab);
 
-        void moveRight(gcn::Tab *tab);
+        void moveRight(Tab *tab);
 */
         void adjustTabPositions();
 
@@ -155,8 +171,18 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
         void setBlockSwitching(bool b)
         { mBlockSwitching = b; }
 
+        void setWidth(int width);
+
+        void setHeight(int height);
+
+        void setSize(int width, int height);
+
+        void setDimension(const gcn::Rectangle &dimension);
+
+        void death(const gcn::Event &event);
+
     private:
-        typedef std::vector< std::pair<gcn::Tab*, gcn::Widget*> > TabContainer;
+        typedef std::vector <std::pair<Tab*, gcn::Widget*> > TabContainer;
 
         /** The tab arrows */
         gcn::Button *mArrowButton[2];
@@ -170,6 +196,24 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
          */
         void updateTabsWidth();
 
+
+
+        Tab* mSelectedTab;
+
+        gcn::Container* mTabContainer;
+
+        gcn::Container* mWidgetContainer;
+
+        std::vector<Tab*> mTabsToDelete;
+
+        std::vector<std::pair<Tab*, gcn::Widget*> > mTabs;
+
+        bool mOpaque;
+
+
+
+
+
         /**
          * The overall width of all tab.
          */
@@ -187,6 +231,7 @@ class TabbedArea final : public gcn::TabbedArea, public gcn::WidgetListener
         int mVisibleTabsWidth;
 
 
+
         /**
          * The tab scroll index. When scrolling with the arrows, the tabs
          * must be displayed according to the current index.