Initial commit.

This code based on mana client http://www.gitorious.org/mana/mana
and my private repository.

1 files changed, 585 insertions, 0 deletions

diff --git a/src/gui/widgets/table.cpp b/src/gui/widgets/table.cpp
new file mode 100644
index 000000000..39ef719ef
--- /dev/null
+++ b/src/gui/widgets/table.cpp
@@ -0,0 +1,585 @@
+/*
+ *  The Mana Client
+ *  Copyright (C) 2008-2009  The Mana World Development Team
+ *  Copyright (C) 2009-2010  The Mana Developers
+ *
+ *  This file is part of The Mana Client.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "gui/widgets/table.h"
+
+#include "client.h"
+#include "configuration.h"
+
+#include "gui/sdlinput.h"
+#include "gui/theme.h"
+
+#include "utils/dtor.h"
+
+#include <guichan/actionlistener.hpp>
+#include <guichan/graphics.hpp>
+#include <guichan/key.hpp>
+
+float GuiTable::mAlpha = 1.0;
+
+class GuiTableActionListener : public gcn::ActionListener
+{
+public:
+    GuiTableActionListener(GuiTable *_table, gcn::Widget *_widget,
+                           int _row, int _column);
+
+    virtual ~GuiTableActionListener();
+
+    virtual void action(const gcn::ActionEvent& actionEvent);
+
+protected:
+    GuiTable *mTable;
+    int mRow;
+    int mColumn;
+    gcn::Widget *mWidget;
+};
+
+
+GuiTableActionListener::GuiTableActionListener(GuiTable *table,
+                                               gcn::Widget *widget, int row,
+                                               int column) :
+    mTable(table),
+    mRow(row),
+    mColumn(column),
+    mWidget(widget)
+{
+    if (widget)
+    {
+        widget->addActionListener(this);
+        widget->_setParent(table);
+    }
+}
+
+GuiTableActionListener::~GuiTableActionListener()
+{
+    if (mWidget)
+    {
+        mWidget->removeActionListener(this);
+        mWidget->_setParent(NULL);
+    }
+}
+
+void GuiTableActionListener::action(const gcn::ActionEvent
+                                    &actionEvent _UNUSED_)
+{
+    mTable->setSelected(mRow, mColumn);
+    mTable->distributeActionEvent();
+}
+
+
+GuiTable::GuiTable(TableModel *initial_model, gcn::Color background,
+                   bool opacity) :
+    mLinewiseMode(false),
+    mWrappingEnabled(false),
+    mOpaque(opacity),
+    mBackgroundColor(background),
+    mModel(NULL),
+    mSelectedRow(0),
+    mSelectedColumn(0),
+    mTopWidget(NULL)
+{
+    setModel(initial_model);
+    setFocusable(true);
+
+    addMouseListener(this);
+    addKeyListener(this);
+}
+
+GuiTable::~GuiTable()
+{
+    uninstallActionListeners();
+    delete mModel;
+    mModel = 0;
+}
+
+TableModel *GuiTable::getModel() const
+{
+    return mModel;
+}
+
+void GuiTable::setModel(TableModel *new_model)
+{
+    if (mModel)
+    {
+        uninstallActionListeners();
+        mModel->removeListener(this);
+    }
+
+    mModel = new_model;
+    installActionListeners();
+
+    if (new_model)
+    {
+        new_model->installListener(this);
+        recomputeDimensions();
+    }
+}
+
+void GuiTable::recomputeDimensions()
+{
+    if (!mModel)
+        return;
+
+    int rows_nr = mModel->getRows();
+    int columns_nr = mModel->getColumns();
+    int width = 0;
+    int height = 0;
+
+    if (mSelectedRow >= rows_nr)
+        mSelectedRow = rows_nr - 1;
+
+    if (mSelectedColumn >= columns_nr)
+        mSelectedColumn = columns_nr - 1;
+
+    for (int i = 0; i < columns_nr; i++)
+        width += getColumnWidth(i);
+
+    height = getRowHeight() * rows_nr;
+
+    setWidth(width);
+    setHeight(height);
+}
+
+void GuiTable::setSelected(int row, int column)
+{
+    mSelectedColumn = column;
+    mSelectedRow = row;
+}
+
+int GuiTable::getSelectedRow() const
+{
+    return mSelectedRow;
+}
+
+int GuiTable::getSelectedColumn() const
+{
+    return mSelectedColumn;
+}
+
+void GuiTable::setLinewiseSelection(bool linewise)
+{
+    mLinewiseMode = linewise;
+}
+
+int GuiTable::getRowHeight() const
+{
+    if (mModel)
+        return mModel->getRowHeight() + 1; // border
+    else
+        return 0;
+}
+
+int GuiTable::getColumnWidth(int i) const
+{
+    if (mModel)
+        return mModel->getColumnWidth(i) + 1; // border
+    else
+        return 0;
+}
+
+void GuiTable::setSelectedRow(int selected)
+{
+    if (!mModel)
+    {
+        mSelectedRow = -1;
+    }
+    else
+    {
+        if (selected < 0 && !mWrappingEnabled)
+        {
+            mSelectedRow = -1;
+        }
+        else if (selected >= mModel->getRows() && mWrappingEnabled)
+        {
+            mSelectedRow = 0;
+        }
+        else if ((selected >= mModel->getRows() && !mWrappingEnabled) ||
+                 (selected < 0 && mWrappingEnabled))
+        {
+            mSelectedRow = mModel->getRows() - 1;
+        }
+        else
+        {
+            mSelectedRow = selected;
+        }
+    }
+}
+
+void GuiTable::setSelectedColumn(int selected)
+{
+    if (!mModel)
+    {
+        mSelectedColumn = -1;
+    }
+    else
+    {
+        if ((selected >= mModel->getColumns() && mWrappingEnabled) ||
+            (selected < 0 && !mWrappingEnabled))
+        {
+            mSelectedColumn = 0;
+        }
+        else if ((selected >= mModel->getColumns() && !mWrappingEnabled) ||
+                 (selected < 0 && mWrappingEnabled))
+        {
+            mSelectedColumn = mModel->getColumns() - 1;
+        }
+        else
+        {
+            mSelectedColumn = selected;
+        }
+    }
+}
+
+void GuiTable::uninstallActionListeners()
+{
+    delete_all(mActionListeners);
+    mActionListeners.clear();
+}
+
+void GuiTable::installActionListeners()
+{
+    if (!mModel)
+        return;
+
+    int rows = mModel->getRows();
+    int columns = mModel->getColumns();
+
+    for (int row = 0; row < rows; ++row)
+    {
+        for (int column = 0; column < columns; ++column)
+        {
+            gcn::Widget *widget = mModel->getElementAt(row, column);
+            if (widget)
+            {
+                mActionListeners.push_back(new GuiTableActionListener(
+                    this, widget, row, column));
+            }
+        }
+    }
+
+    _setFocusHandler(_getFocusHandler()); // propagate focus handler to widgets
+}
+
+// -- widget ops
+void GuiTable::draw(gcn::Graphics* graphics)
+{
+    if (!mModel || !getRowHeight())
+        return;
+
+    if (Client::getGuiAlpha() != mAlpha)
+        mAlpha = Client::getGuiAlpha();
+
+    if (mOpaque)
+    {
+        graphics->setColor(Theme::getThemeColor(Theme::BACKGROUND,
+                           static_cast<int>(mAlpha * 255.0f)));
+        graphics->fillRectangle(gcn::Rectangle(0, 0, getWidth(), getHeight()));
+    }
+
+    // First, determine how many rows we need to draw, and where we should start.
+    int first_row = -(getY() / getRowHeight());
+
+    if (first_row < 0)
+        first_row = 0;
+
+    int rows_nr = 1 + (getHeight() / getRowHeight()); // May overestimate
+                                                      // by one.
+
+    int max_rows_nr = mModel->getRows() - first_row; // clip if neccessary:
+    if (max_rows_nr < rows_nr)
+        rows_nr = max_rows_nr;
+
+    // Now determine the first and last column
+    // Take the easy way out; these are usually bounded and all visible.
+    int first_column = 0;
+    int last_column1 = mModel->getColumns();
+
+    // Set up everything for drawing
+    int height = getRowHeight();
+    int y_offset = first_row * height;
+
+    for (int r = first_row; r < first_row + rows_nr; ++r)
+    {
+        int x_offset = 0;
+
+        for (int c = first_column; c + 1 <= last_column1; ++c)
+        {
+            gcn::Widget *widget = mModel->getElementAt(r, c);
+            int width = getColumnWidth(c);
+            if (widget)
+            {
+                gcn::Rectangle bounds(x_offset, y_offset, width, height);
+
+                if (widget == mTopWidget)
+                {
+                    bounds.height = widget->getHeight();
+                    bounds.width = widget->getWidth();
+                }
+
+                widget->setDimension(bounds);
+
+                graphics->setColor(Theme::getThemeColor(Theme::HIGHLIGHT,
+                        static_cast<int>(mAlpha * 255.0f)));
+
+                if (mLinewiseMode && r == mSelectedRow && c == 0)
+                {
+                    graphics->fillRectangle(gcn::Rectangle(0, y_offset,
+                                            getWidth(), height));
+                }
+                else if (!mLinewiseMode &&
+                         c == mSelectedColumn && r == mSelectedRow)
+                {
+                    graphics->fillRectangle(gcn::Rectangle(x_offset, y_offset,
+                                                           width, height));
+                }
+
+                graphics->pushClipArea(bounds);
+                widget->draw(graphics);
+                graphics->popClipArea();
+            }
+
+            x_offset += width;
+        }
+
+        y_offset += height;
+    }
+
+    if (mTopWidget)
+    {
+        gcn::Rectangle bounds = mTopWidget->getDimension();
+        graphics->pushClipArea(bounds);
+        mTopWidget->draw(graphics);
+        graphics->popClipArea();
+    }
+}
+
+void GuiTable::moveToTop(gcn::Widget *widget)
+{
+    gcn::Widget::moveToTop(widget);
+    mTopWidget = widget;
+}
+
+void GuiTable::moveToBottom(gcn::Widget *widget)
+{
+    gcn::Widget::moveToBottom(widget);
+    if (widget == mTopWidget)
+        mTopWidget = NULL;
+}
+
+gcn::Rectangle GuiTable::getChildrenArea() const
+{
+    return gcn::Rectangle(0, 0, getWidth(), getHeight());
+}
+
+// -- KeyListener notifications
+void GuiTable::keyPressed(gcn::KeyEvent& keyEvent)
+{
+    gcn::Key key = keyEvent.getKey();
+
+    if (key.getValue() == Key::ENTER || key.getValue() == Key::SPACE)
+    {
+        distributeActionEvent();
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::UP)
+    {
+        setSelectedRow(mSelectedRow - 1);
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::DOWN)
+    {
+        setSelectedRow(mSelectedRow + 1);
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::LEFT)
+    {
+        setSelectedColumn(mSelectedColumn - 1);
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::RIGHT)
+    {
+        setSelectedColumn(mSelectedColumn + 1);
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::HOME)
+    {
+        setSelectedRow(0);
+        setSelectedColumn(0);
+        keyEvent.consume();
+    }
+    else if (key.getValue() == Key::END && mModel)
+    {
+        setSelectedRow(mModel->getRows() - 1);
+        setSelectedColumn(mModel->getColumns() - 1);
+        keyEvent.consume();
+    }
+}
+
+// -- MouseListener notifications
+void GuiTable::mousePressed(gcn::MouseEvent& mouseEvent)
+{
+    if (!mModel)
+        return;
+
+    if (mouseEvent.getButton() == gcn::MouseEvent::LEFT)
+    {
+        int row = getRowForY(mouseEvent.getY());
+        int column = getColumnForX(mouseEvent.getX());
+
+        if (row > -1 && column > -1 &&
+            row < mModel->getRows() && column < mModel->getColumns())
+        {
+            mSelectedColumn = column;
+            mSelectedRow = row;
+        }
+
+        distributeActionEvent();
+    }
+}
+
+void GuiTable::mouseWheelMovedUp(gcn::MouseEvent& mouseEvent)
+{
+    if (isFocused())
+    {
+        if (getSelectedRow() > 0 || (getSelectedRow() == 0
+            && mWrappingEnabled))
+        {
+            setSelectedRow(getSelectedRow() - 1);
+        }
+
+        mouseEvent.consume();
+    }
+}
+
+void GuiTable::mouseWheelMovedDown(gcn::MouseEvent& mouseEvent)
+{
+    if (isFocused())
+    {
+        setSelectedRow(getSelectedRow() + 1);
+
+        mouseEvent.consume();
+    }
+}
+
+void GuiTable::mouseDragged(gcn::MouseEvent& mouseEvent)
+{
+    if (mouseEvent.getButton() != gcn::MouseEvent::LEFT)
+        return;
+
+    // Make table selection update on drag
+    const int x = std::max(0, mouseEvent.getX());
+    const int y = std::max(0, mouseEvent.getY());
+
+    setSelectedRow(getRowForY(y));
+    setSelectedColumn(getColumnForX(x));
+}
+
+// -- TableModelListener notifications
+void GuiTable::modelUpdated(bool completed)
+{
+    if (completed)
+    {
+        recomputeDimensions();
+        installActionListeners();
+    }
+    else
+    { // before the update?
+        mTopWidget = NULL; // No longer valid in general
+        uninstallActionListeners();
+    }
+}
+
+gcn::Widget *GuiTable::getWidgetAt(int x, int y) const
+{
+    int row = getRowForY(y);
+    int column = getColumnForX(x);
+
+    if (mTopWidget && mTopWidget->getDimension().isPointInRect(x, y))
+        return mTopWidget;
+
+    if (mModel && row > -1 && column > -1)
+    {
+        gcn::Widget *w = mModel->getElementAt(row, column);
+        if (w && w->isFocusable())
+            return w;
+        else
+            return NULL; // Grab the event locally
+    }
+    else
+        return NULL;
+}
+
+int GuiTable::getRowForY(int y) const
+{
+   int row = -1;
+
+   if (getRowHeight() > 0)
+       row = y / getRowHeight();
+
+   if (!mModel || row < 0 || row >= mModel->getRows())
+       return -1;
+   else
+       return row;
+}
+
+int GuiTable::getColumnForX(int x) const
+{
+    if (!mModel)
+        return -1;
+
+    int column;
+    int delta = 0;
+
+    for (column = 0; column < mModel->getColumns(); column++)
+    {
+        delta += getColumnWidth(column);
+        if (x <= delta)
+            break;
+    }
+
+    if (column < 0 || column >= mModel->getColumns())
+        return -1;
+    else
+        return column;
+}
+
+void GuiTable::_setFocusHandler(gcn::FocusHandler* focusHandler)
+{
+// add check for focusHandler. may be need remove it?
+
+    if (!mModel || !focusHandler)
+        return;
+
+    gcn::Widget::_setFocusHandler(focusHandler);
+
+    if (mModel)
+    {
+        for (int r = 0; r < mModel->getRows(); ++r)
+        {
+            for (int c = 0; c < mModel->getColumns(); ++c)
+            {
+                gcn::Widget *w = mModel->getElementAt(r, c);
+                if (w)
+                    w->_setFocusHandler(focusHandler);
+            }
+        }
+    }
+}