Extending the internal handling of colors

The internal storage for colors was in the file color.h/color.cpp. It
mainly managed the colors in the chat.

The Color class was extended to be more generic now and it stores
gcn::Color objects instead of integers now. A lot of new colortypes are
now available, though not many of them are used for now, that will come
in the next patches.

The Color class was renamed to Palette and color.{h,cpp} to
palette.{h,cpp} to better describe its purpose.

The color config gui now lists the new colors, even changes them, but the
result is not displayed properly for now.

13 files changed, 711 insertions, 104 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 9fdca23a..6565a1b0 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -81,8 +81,6 @@ SET(SRCS
     gui/chatinput.h
     gui/checkbox.cpp
     gui/checkbox.h
-    gui/color.cpp
-    gui/color.h
     gui/confirm_dialog.cpp
     gui/confirm_dialog.h
     gui/connection.cpp
@@ -140,6 +138,8 @@ SET(SRCS
     gui/npc_text.h
     gui/ok_dialog.cpp
     gui/ok_dialog.h
+    gui/palette.cpp
+    gui/palette.h
     gui/passwordfield.cpp
     gui/passwordfield.h
     gui/playerbox.cpp
@@ -205,6 +205,7 @@ SET(SRCS
     gui/textbox.h
     gui/textfield.cpp
     gui/textfield.h
+    gui/textrenderer.h
     gui/trade.cpp
     gui/trade.h
     gui/truetypefont.cpp
diff --git a/src/Makefile.am b/src/Makefile.am
index c4265dec..b3bdde9d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -31,8 +31,6 @@ aethyra_SOURCES = gui/widgets/dropdown.cpp \
 	      gui/chatinput.h \
 	      gui/checkbox.cpp \
 	      gui/checkbox.h \
-	      gui/color.cpp \
-	      gui/color.h \
 	      gui/confirm_dialog.cpp \
 	      gui/confirm_dialog.h \
 	      gui/connection.cpp \
@@ -90,6 +88,8 @@ aethyra_SOURCES = gui/widgets/dropdown.cpp \
 	      gui/npc_text.h \
 	      gui/ok_dialog.cpp \
 	      gui/ok_dialog.h \
+	      gui/palette.cpp \
+	      gui/palette.h \
 	      gui/passwordfield.cpp \
 	      gui/passwordfield.h \
 	      gui/playerbox.cpp \
@@ -155,6 +155,7 @@ aethyra_SOURCES = gui/widgets/dropdown.cpp \
 	      gui/textbox.h \
 	      gui/textfield.cpp \
 	      gui/textfield.h \
+              gui/textrenderer.h \
 	      gui/trade.cpp \
 	      gui/trade.h \
 	      gui/truetypefont.cpp \
diff --git a/src/gui/browserbox.cpp b/src/gui/browserbox.cpp
index 2b690b21..46c8bdf1 100644
--- a/src/gui/browserbox.cpp
+++ b/src/gui/browserbox.cpp
@@ -25,8 +25,8 @@
 #include <guichan/graphics.hpp>
 
 #include "browserbox.h"
-#include "color.h"
 #include "linkhandler.h"
+#include "palette.h"
 #include "truetypefont.h"
 
 BrowserBox::BrowserBox(unsigned int mode, bool opaque):
@@ -250,16 +250,15 @@ void BrowserBox::draw(gcn::Graphics *graphics)
 
     if (mOpaque)
     {
-        graphics->setColor(gcn::Color(BGCOLOR));
+        graphics->setColor(guiPalette->getColor(Palette::BACKGROUND));
         graphics->fillRectangle(gcn::Rectangle(0, 0, getWidth(), getHeight()));
     }
 
     if (mSelectedLink >= 0)
     {
-        bool valid;
         if ((mHighMode & BACKGROUND))
         {
-            graphics->setColor(gcn::Color(textColor->getColor('H', valid)));
+            graphics->setColor(guiPalette->getColor(Palette::HIGHLIGHT));
             graphics->fillRectangle(gcn::Rectangle(
                         mLinks[mSelectedLink].x1,
                         mLinks[mSelectedLink].y1,
@@ -270,7 +269,7 @@ void BrowserBox::draw(gcn::Graphics *graphics)
 
         if ((mHighMode & UNDERLINE))
         {
-            graphics->setColor(gcn::Color(textColor->getColor('<', valid)));
+            graphics->setColor(guiPalette->getColor(Palette::HYPERLINK));
             graphics->drawLine(
                     mLinks[mSelectedLink].x1,
                     mLinks[mSelectedLink].y2,
@@ -284,11 +283,11 @@ void BrowserBox::draw(gcn::Graphics *graphics)
     int link = 0;
     TrueTypeFont *font = static_cast<TrueTypeFont*>(getFont());
 
-    graphics->setColor(BLACK);
+    graphics->setColor(guiPalette->getColor(Palette::TEXT));
     for (TextRowIterator i = mTextRows.begin(); i != mTextRows.end(); i++)
     {
-        int selColor = BLACK;
-        int prevColor = selColor;
+        const gcn::Color *selColor = &guiPalette->getColor(Palette::TEXT);
+        const gcn::Color *prevColor = selColor;
         std::string row = *(i);
         bool wrapped = false;
         x = 0;
@@ -336,7 +335,7 @@ void BrowserBox::draw(gcn::Graphics *graphics)
                     else
                     {
                         bool valid;
-                        int rgb = textColor->getColor(c, valid);
+                        const gcn::Color *col = &guiPalette->getColor(c, valid);
                         if (c == '<')
                         {
                             const int size = mLinks[link].x2 - mLinks[link].x1;
@@ -349,7 +348,7 @@ void BrowserBox::draw(gcn::Graphics *graphics)
                         }
                         if (valid)
                         {
-                            selColor = rgb;
+                            selColor = col;
                         }
                     }
                     start += 3;
@@ -359,7 +358,7 @@ void BrowserBox::draw(gcn::Graphics *graphics)
                         break;
                     }
                 }
-                graphics->setColor(gcn::Color(selColor));
+                graphics->setColor(*selColor);
             }
 
             std::string::size_type len =
diff --git a/src/gui/listbox.cpp b/src/gui/listbox.cpp
index 82011239..e53a1652 100644
--- a/src/gui/listbox.cpp
+++ b/src/gui/listbox.cpp
@@ -25,8 +25,8 @@
 #include <guichan/key.hpp>
 #include <guichan/listmodel.hpp>
 
-#include "color.h"
 #include "listbox.h"
+#include "palette.h"
 
 #include "../configuration.h"
 
@@ -45,13 +45,8 @@ void ListBox::draw(gcn::Graphics *graphics)
     if (config.getValue("guialpha", 0.8) != mAlpha)
         mAlpha = config.getValue("guialpha", 0.8);
 
-    bool valid;
-    const int red = (textColor->getColor('H', valid) >> 16) & 0xFF;
-    const int green = (textColor->getColor('H', valid) >> 8) & 0xFF;
-    const int blue = textColor->getColor('H', valid) & 0xFF;
-    const int alpha = (int)(mAlpha * 255.0f);
-
-    graphics->setColor(gcn::Color(red, green, blue, alpha));
+    graphics->setColor(guiPalette->getColor(Palette::HIGHLIGHT,
+            (int)(mAlpha * 255.0f)));
     graphics->setFont(getFont());
 
     const int fontHeight = getFont()->getHeight();
diff --git a/src/gui/palette.cpp b/src/gui/palette.cpp
new file mode 100644
index 00000000..a79f2050
--- /dev/null
+++ b/src/gui/palette.cpp
@@ -0,0 +1,317 @@
+/*
+ *  Configurable text colors
+ *  Copyright (C) 2008  Douglas Boffey <dougaboffey@netscape.net>
+ *  Copyright (C) 2009  The Mana World Development Team
+ *
+ *  This file is part of Aethyra.
+ *
+ *  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, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <math.h>
+
+#include "palette.h"
+#include "gui.h"
+
+#include "../configuration.h"
+#include "../game.h"
+
+#include "../utils/gettext.h"
+#include "../utils/stringutils.h"
+
+const gcn::Color Palette::BLACK = gcn::Color(0, 0, 0);
+
+const gcn::Color Palette::RAINBOW_COLORS[8] = {
+    gcn::Color(255, 0, 0),
+    gcn::Color(255, 153, 0),
+    gcn::Color(255, 255, 0),
+    gcn::Color(0, 153, 0),
+    gcn::Color(0, 204, 204),
+    gcn::Color(51, 0, 153),
+    gcn::Color(153, 0, 153)
+};
+/** Number of Elemets of RAINBOW_COLORS */
+const int Palette::RAINBOW_COLOR_COUNT = 7;
+
+std::string Palette::getConfigName(const std::string& typeName)
+{
+    std::string res = "Color" + typeName;
+
+    int pos = 5;
+    for (unsigned int i = 0; i < typeName.length(); i++)
+    {
+        if (i==0 || typeName[i] == '_')
+        {
+            if (i > 0)
+            {
+                i++;
+            }
+            res[pos] = typeName[i];
+        }
+        else
+        {
+           res[pos] = tolower(typeName[i]);
+        }
+        pos++;
+    }
+    res.erase(pos, res.length() - pos);
+
+    return res;
+}
+
+DEFENUMNAMES(ColorType, COLOR_TYPE);
+
+const int Palette::GRADIENT_DELAY = 20;
+
+Palette::Palette() : 
+    mRainbowTime(tick_time),
+    mColVector(ColVector(TYPE_COUNT)),
+    mGradVector()
+{
+    std::string indent = "  ";
+    addColor(TEXT, 0x000000, STATIC, _("Text"));
+    addColor(SHADOW, 0x000000, STATIC, indent + _("Text Shadow"), 0);
+    addColor(OUTLINE, 0x000000, STATIC, indent + _("Text Outline"), 0);
+
+    addColor(BACKGROUND, 0xffffff, STATIC, _("Background"));
+
+    addColor(HIGHLIGHT, 0xebc873, STATIC, _("Highlight"), 'H');
+    addColor(SHOP_WARNING, 0x910000, STATIC, indent +
+            _("Item too expensive"));
+
+    addColor(CHAT, 0x000000, STATIC, _("Chat"), 'C');
+    addColor(GM, 0xff0000, STATIC, indent + _("GM"), 'G');
+    addColor(PLAYER, 0x1fa052, STATIC, indent + _("Player"), 'Y');
+    addColor(WHISPER, 0x0000ff, STATIC, indent + _("Whisper"), 'W');
+    addColor(IS, 0xa08527, STATIC, indent + _("Is"), 'I');
+    addColor(PARTY, 0xff00d8, STATIC, indent + _("Party"), 'P');
+    addColor(SERVER, 0x8415e2, STATIC, indent + _("Server"), 'S');
+    addColor(LOGGER, 0x919191, STATIC, indent + _("Logger"), 'L');
+    addColor(HYPERLINK, 0xe50d0d, STATIC, indent + _("Hyperlink"), '<');
+
+    addColor(BEING, 0xffffff, STATIC, _("Being"), 0);
+    addColor(PC, 0xffffff, STATIC, indent + _("Other Player's Names"), 0);
+    addColor(SELF, 0xff8040, STATIC, indent + _("Own Name"), 0);
+    addColor(GM_NAME, 0x00ff00, STATIC, indent + _("GM Names"), 0);
+    addColor(NPC, 0xc8c8ff, STATIC, indent + _("NPCs"), 0);
+    addColor(MONSTER, 0xff4040, STATIC, indent + _("Monsters"), 0);
+
+    addColor(PARTICLE, 0xffffff, STATIC, _("Particle Effects"), 0);
+    addColor(PICKUP_INFO, 0x28dc28, STATIC, indent + _("Pickup Notification"),
+            0);
+    addColor(EXP_INFO, 0xffff00, STATIC, indent + _("Exp Notification"),0);
+    addColor(HIT_PLAYER_MONSTER, 0x0064ff, STATIC,
+            indent + _("Player hits Monster"), 0);
+    addColor(HIT_MONSTER_PLAYER, 0xff3232, STATIC,
+            indent + _("Monster hits Player"), 0);
+    addColor(HIT_CRITICAL, 0xff0000, RAINBOW,
+            indent + _("Critical Hit"), 0);
+    addColor(MISS, 0xffff00, STATIC, indent + _("Misses"), 0);
+    commit(true);
+}
+
+Palette::~Palette()
+{
+    const std::string *configName;
+    for (ColVector::iterator col = mColVector.begin(),
+         colEnd = mColVector.end(); col != colEnd; ++col)
+    {
+        configName = &ColorTypeNames[col->type];
+        config.setValue(*configName + "Gradient", col->grad);
+        if (col->grad == STATIC)
+        {
+            config.setValue(*configName, toString(col->getRGB()));
+        }
+    }
+}
+
+const gcn::Color& Palette::getColor(char c, bool &valid)
+ {
+    for (ColVector::const_iterator col = mColVector.begin(),
+            colEnd = mColVector.end(); col != colEnd; ++col)
+    {
+        if (col->ch == c)
+        {
+            valid = true;
+            return col->color;
+        }
+    }
+    valid = false;
+    return BLACK;
+}
+
+void Palette::setColor(ColorType type, int r, int g, int b)
+{
+    mColVector[type].color.r = r;
+    mColVector[type].color.g = g;
+    mColVector[type].color.b = b;
+}
+
+void Palette::setGradient(ColorType type, GradientType grad)
+{
+    ColorElem *elem = &mColVector[type];
+    if (elem->grad != STATIC && grad == STATIC)
+    {
+        for (unsigned int i = 0; i < mGradVector.size(); i++)
+        {
+            if (mGradVector[i] == elem)
+            {
+                mGradVector.erase(mGradVector.begin() + i);
+                break;
+            }
+        }
+    }
+    else if (elem->grad == STATIC && grad != STATIC)
+    {
+        mGradVector.push_back(elem);
+    }
+
+    if (elem->grad != grad)
+    {
+        elem->grad = grad;
+    }
+}
+
+std::string Palette::getElementAt(int i)
+{
+    if (i < 0 || i >= getNumberOfElements())
+    {
+        return "";
+    }
+    return mColVector[i].text;
+}
+
+Palette::ColorType Palette::getColorTypeAt(int i)
+{
+    if (i < 0 || i >= getNumberOfElements())
+    {
+        return CHAT;
+    }
+    return mColVector[i].type;
+}
+
+void Palette::commit(bool commitNonStatic)
+{
+    for (ColVector::iterator i = mColVector.begin(), iEnd = mColVector.end();
+         i != iEnd; ++i)
+    {
+        i->committedGrad = i->grad;
+        if (commitNonStatic || i->grad == STATIC)
+        {
+            i->committedColor = i->color;
+        }
+    }
+}
+
+void Palette::rollback()
+{
+    for (ColVector::iterator i = mColVector.begin(), iEnd = mColVector.end();
+         i != iEnd;
+         ++i)
+    {
+        i->grad = i->committedGrad;
+        if (i->grad == STATIC)
+        {
+            i->color = i->committedColor;
+        }
+    }
+}
+
+void Palette::addColor(Palette::ColorType type, int rgb,
+        Palette::GradientType grad,
+        const std::string &text, char c)
+{
+    const std::string *configName = &ColorTypeNames[type];
+    gcn::Color trueCol = (int)config.getValue(*configName, rgb);
+    grad = (GradientType)config.getValue(*configName + "Gradient", grad);
+    mColVector[type].set(type, trueCol, grad, text, c);
+    if (grad != STATIC)
+    {
+        mGradVector.push_back(&mColVector[type]);
+    }
+}
+
+void Palette::advanceGradient ()
+{
+    if (get_elapsed_time(mRainbowTime) > 5)
+    {
+        int pos, colIndex, colVal;
+        // For slower systems, advance can be greater than one (adcanve > 1
+        // skips advance-1 steps). Should make gradient look the same
+        // independent of the framerate.
+        int advance = get_elapsed_time(mRainbowTime) / 5;
+        double startColVal, destColVal;
+
+        for (unsigned int i = 0; i < mGradVector.size(); i++)
+        {
+            mGradVector[i]->gradientIndex =
+                    (mGradVector[i]->gradientIndex + advance) %
+                    (GRADIENT_DELAY *
+                    ((mGradVector[i]->grad == SPECTRUM) ? 6 :
+                    RAINBOW_COLOR_COUNT));
+
+            pos = mGradVector[i]->gradientIndex % GRADIENT_DELAY;
+            colIndex = mGradVector[i]->gradientIndex / GRADIENT_DELAY;
+
+            if (mGradVector[i]->grad == SPECTRUM)
+            {
+                if (colIndex % 2)
+                { // falling curve
+                    colVal = (int)(255.0 *
+                            (cos(M_PI * pos / GRADIENT_DELAY) + 1) / 2);
+                }
+                else
+                { // ascending curve
+                    colVal = (int)(255.0 *
+                            (cos(M_PI * (GRADIENT_DELAY-pos) / GRADIENT_DELAY) +
+                            1) / 2);
+                }
+
+                mGradVector[i]->color.r =
+                        (colIndex == 0 || colIndex == 5) ? 255 :
+                        (colIndex == 1 || colIndex == 4) ? colVal : 0;
+                mGradVector[i]->color.g =
+                        (colIndex == 1 || colIndex == 2) ? 255 :
+                        (colIndex == 0 || colIndex == 3) ? colVal : 0;
+                mGradVector[i]->color.b =
+                        (colIndex == 3 || colIndex == 4) ? 255 :
+                        (colIndex == 2 || colIndex == 5) ? colVal : 0;
+            }
+            else
+            {
+                const gcn::Color* startCol = &RAINBOW_COLORS[colIndex];
+                const gcn::Color* destCol =
+                        &RAINBOW_COLORS[(colIndex + 1) % RAINBOW_COLOR_COUNT];
+
+                startColVal = (cos(M_PI * pos / GRADIENT_DELAY) + 1) / 2;
+                destColVal = 1 - startColVal;
+
+                mGradVector[i]->color.r =(int)(
+                        startColVal * startCol->r +
+                        destColVal * destCol->r);
+
+                mGradVector[i]->color.g =(int)(
+                        startColVal * startCol->g +
+                        destColVal * destCol->g);
+
+                mGradVector[i]->color.b =(int)(
+                        startColVal * startCol->b +
+                        destColVal * destCol->b);
+            }
+        }
+
+        mRainbowTime = tick_time;
+    }
+}
diff --git a/src/gui/palette.h b/src/gui/palette.h
new file mode 100644
index 00000000..a372d6cd
--- /dev/null
+++ b/src/gui/palette.h
@@ -0,0 +1,297 @@
+/*
+ *  Configurable text colors
+ *  Copyright (C) 2008  Douglas Boffey <dougaboffey@netscape.net>
+ *  Copyright (C) 2009  The Mana World Development Team
+ *
+ *  This file is part of Aethyra.
+ *
+ *  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, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef PALETTE_H
+#define PALETTE_H
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include <guichan/listmodel.hpp>
+#include <guichan/color.hpp>
+
+// Generate strings from an enum ... some preprocessor fun.
+#define EDEF(a) a,
+#define ECONFIGSTR(a) Palette::getConfigName(#a),
+
+#define TEXTENUM(name,def)\
+    enum name { def(EDEF) };\
+    static const std::string name ## Names[];
+#define DEFENUMNAMES(name,def)\
+    const std::string Palette::name ## Names[] = { def(ECONFIGSTR) "" };
+
+/**
+ * Class controlling the game's color palette.
+ */
+class Palette : public gcn::ListModel
+{
+    public:
+        /** List of all colors that are configurable. */
+        #define COLOR_TYPE(ENTRY)\
+            ENTRY(TEXT)\
+            ENTRY(SHADOW)\
+            ENTRY(OUTLINE)\
+            ENTRY(BACKGROUND)\
+            ENTRY(HIGHLIGHT)\
+            ENTRY(SHOP_WARNING)\
+            ENTRY(CHAT)\
+            ENTRY(GM)\
+            ENTRY(PLAYER)\
+            ENTRY(WHISPER)\
+            ENTRY(IS)\
+            ENTRY(PARTY)\
+            ENTRY(SERVER)\
+            ENTRY(LOGGER)\
+            ENTRY(HYPERLINK)\
+            ENTRY(BEING)\
+            ENTRY(PC)\
+            ENTRY(SELF)\
+            ENTRY(GM_NAME)\
+            ENTRY(NPC)\
+            ENTRY(MONSTER)\
+            ENTRY(PARTICLE)\
+            ENTRY(EXP_INFO)\
+            ENTRY(PICKUP_INFO)\
+            ENTRY(HIT_PLAYER_MONSTER)\
+            ENTRY(HIT_MONSTER_PLAYER)\
+            ENTRY(HIT_CRITICAL)\
+            ENTRY(MISS)\
+            ENTRY(TYPE_COUNT)\
+
+        TEXTENUM(ColorType, COLOR_TYPE);
+
+        /** Colors can be static or can alter over time. */
+        enum GradientType {
+            STATIC,
+            SPECTRUM,
+            RAINBOW
+        };
+
+        /**
+         * Constructor
+         */
+        Palette();
+
+        /**
+         * Destructor
+         */
+        ~Palette();
+
+        /**
+         * Returns the color associated with a character, if it exists. Returns
+         * Palette::BLACK if the character is not found.
+         *
+         * @param c character requested
+         * @param valid indicate whether character is known
+         *
+         * @return the requested color or Palette::BLACK
+         */
+        const gcn::Color& getColor(char c, bool &valid);
+
+        /**
+         * Gets the color with the associated type. Sets the alpha channel
+         * before returning.
+         *
+         * @param type the color type requested
+         * @param alpha alpha channel to use
+         *
+         * @return the requested color
+         */
+        inline const gcn::Color& getColor(ColorType type, int alpha = 255)
+        {
+            gcn::Color* col = &mColVector[type].color;
+            col->a = alpha;
+            return *col;
+        }
+
+        /**
+        * Gets the GradientType used by the specified color.
+        *
+        * @param type the color type of the color
+        *
+        * @return the gradient type of the color with the given index
+        */
+        inline GradientType getGradientType(ColorType type)
+        {
+            return mColVector[type].grad;
+        }
+
+        /**
+        * Get the character used by the specified color.
+        *
+        * @param type the color type of the color
+        *
+        * @return the color char of the color with the given index
+        */
+        inline char getColorChar(ColorType type)
+        {
+            return mColVector[type].ch;
+        }
+
+        /**
+         * Sets the color for the specified type.
+         *
+         * @param type color to be set
+         * @param r red component
+         * @param g green component
+         * @param b blue component
+         */
+        void setColor(ColorType type, int r, int g, int b);
+
+        /**
+         * Sets the gradient type for the specified color.
+         *
+         * @param grad gradient type to set
+         */
+        void setGradient(ColorType type, GradientType grad);
+
+        /**
+         * Returns the number of colors known.
+         *
+         * @return the number of colors known
+         */
+        inline int getNumberOfElements() { return mColVector.size(); }
+
+        /**
+         * Returns the name of the ith color.
+         *
+         * @param i index of color interested in
+         *
+         * @return the name of the color
+         */
+        std::string getElementAt(int i);
+
+        /**
+         * Gets the ColorType used by the color for the element at index i in
+         * the current color model.
+         *
+         * @param i the index of the color
+         *
+         * @return the color type of the color with the given index
+         */
+        ColorType getColorTypeAt(int i);
+
+        /**
+         * Commit the colors
+         */
+        inline void commit()
+        {
+            commit(false);
+        }
+
+        /**
+         * Rollback the colors
+         */
+        void rollback();
+
+        /**
+         * Updates all colors, that are non-static.
+         */
+        void advanceGradient();
+
+    private:
+        /** Black Color Constant */
+        static const gcn::Color BLACK;
+
+        /** Colors used for the rainbow gradient */
+        static const gcn::Color RAINBOW_COLORS[];
+        static const int RAINBOW_COLOR_COUNT;
+        /** Parameter to control the speed of the gradient */
+        static const int GRADIENT_DELAY;
+        /** Time tick, that gradient-type colors were updated the last time. */
+        int mRainbowTime;
+
+        /**
+         * Define a color replacement.
+         *
+         * @param i the index of the color to replace
+         * @param r red component
+         * @param g green component
+         * @param b blue component
+         */
+        void setColorAt(int i, int r, int g, int b);
+
+        /**
+         * Commit the colors. Commit the non-static color values, if
+         * commitNonStatic is true. Only needed in the constructor.
+         */
+        void commit(bool commitNonStatic);
+
+        struct ColorElem
+        {
+            ColorType type;
+            gcn::Color color;
+            gcn::Color committedColor;
+            std::string text;
+            char ch;
+            GradientType grad;
+            GradientType committedGrad;
+            int gradientIndex;
+
+            void set(ColorType type, gcn::Color& color, GradientType grad,
+                    const std::string &text, char c)
+            {
+                ColorElem::type = type;
+                ColorElem::color = color;
+                ColorElem::text = text;
+                ColorElem::ch = c;
+                ColorElem::grad = grad;
+                ColorElem::gradientIndex = rand();
+            }
+
+            inline int getRGB() {
+                return (committedColor.r << 16) | (committedColor.g << 8) |
+                        committedColor.b;
+            }
+        };
+        typedef std::vector<ColorElem> ColVector;
+        /** Vector containing the colors. */
+        ColVector mColVector;
+        std::vector<ColorElem*> mGradVector;
+
+        /**
+         * Initialise color
+         *
+         * @param c character that needs initialising
+         * @param rgb default color if not found in config
+         * @param text identifier of color
+         */
+        void addColor(ColorType type, int rgb, GradientType grad,
+                const std::string &text, char c = 0);
+
+        /**
+         * Prefixes the given string with "Color", lowercases all letters but
+         * the first and all following a '_'. All '_'s will be removed.
+         *
+         * E.g.: HIT_PLAYER_MONSTER -> HitPlayerMonster
+         *
+         * @param typeName string to transform
+         *
+         * @return the transformed string
+         */
+        static std::string getConfigName(const std::string& typeName);
+};
+
+extern Palette *guiPalette;
+
+#endif
diff --git a/src/gui/setup_colors.cpp b/src/gui/setup_colors.cpp
index 31b56b51..4f017e15 100644
--- a/src/gui/setup_colors.cpp
+++ b/src/gui/setup_colors.cpp
@@ -27,9 +27,9 @@
 #include <guichan/widgets/slider.hpp>
 
 #include "browserbox.h"
-#include "color.h"
 #include "itemlinkhandler.h"
 #include "listbox.h"
+#include "palette.h"
 #include "scrollarea.h"
 #include "setup_colors.h"
 #include "slider.h"
@@ -42,12 +42,14 @@
 #include "../utils/gettext.h"
 #include "../utils/stringutils.h"
 
+const std::string Setup_Colors::rawmsg = _("This is what the color looks like");
+
 Setup_Colors::Setup_Colors() :
     mSelected(-1)
 {
     setOpaque(false);
 
-    mColorBox = new ListBox(textColor);
+    mColorBox = new ListBox(guiPalette);
     mColorBox->setActionEventId("color_box");
     mColorBox->addActionListener(this);
 
@@ -131,6 +133,9 @@ Setup_Colors::Setup_Colors() :
 
 Setup_Colors::~Setup_Colors()
 {
+    delete mPreview;
+    delete mPreviewBox;
+
     delete mRedLabel;
     delete mRedSlider;
     delete mRedText;
@@ -143,6 +148,7 @@ Setup_Colors::~Setup_Colors()
     delete mBlueSlider;
     delete mBlueText;
 
+    delete mColorBox;
     delete mScroll;
 }
 
@@ -151,22 +157,22 @@ void Setup_Colors::action(const gcn::ActionEvent &event)
     if (event.getId() == "color_box")
     {
         mSelected = mColorBox->getSelected();
-        int col = textColor->getColorAt(mSelected);
-        char ch = textColor->getColorCharAt(mSelected);
+        Palette::ColorType type = guiPalette->getColorTypeAt(mSelected);
+        const gcn::Color *col = &guiPalette->getColor(type);
+
         std::string msg;
 
+        mPreview->clearRows();
+        char ch = guiPalette->getColorChar(type);
         if (ch == '<')
-            msg = toString("@@|") +
-                  _("This is what the color looks like") + "@@";
+            msg = toString("@@|") + rawmsg + "@@";
         else
-            msg = "##" + toString(ch) +
-                  _("This is what the color looks like");
-
-        mPreview->clearRows();
+            msg = "##" + toString(ch) + rawmsg;
         mPreview->addRow(msg);
-        setEntry(mRedSlider, mRedText, col >> 16);
-        setEntry(mGreenSlider, mGreenText, (col >> 8) & 0xff);
-        setEntry(mBlueSlider, mBlueText, col & 0xff);
+
+        setEntry(mRedSlider, mRedText, col->r);
+        setEntry(mGreenSlider, mGreenText, col->g);
+        setEntry(mBlueSlider, mBlueText, col->b);
         return;
     }
 
@@ -202,16 +208,17 @@ void Setup_Colors::setEntry(gcn::Slider *s, TextField *t, int value)
 
 void Setup_Colors::apply()
 {
-    textColor->commit();
+    guiPalette->commit();
 }
 
 void Setup_Colors::cancel()
 {
-    textColor->rollback();
-    int col = textColor->getColorAt(mSelected);
-    setEntry(mRedSlider, mRedText, col >> 16);
-    setEntry(mGreenSlider, mGreenText, (col >> 8) & 0xff);
-    setEntry(mBlueSlider, mBlueText, col & 0xff);
+    guiPalette->rollback();
+    Palette::ColorType type = guiPalette->getColorTypeAt(mSelected);
+    const gcn::Color *col = &guiPalette->getColor(type);
+    setEntry(mRedSlider, mRedText, col->r);
+    setEntry(mGreenSlider, mGreenText, col->g);
+    setEntry(mBlueSlider, mBlueText, col->b);
 }
 
 void Setup_Colors::listen(const TextField *tf)
@@ -242,8 +249,10 @@ void Setup_Colors::updateColor()
     {
         return;
     }
-    int rgb = static_cast<int>(mRedSlider->getValue()) << 16 |
-              static_cast<int>(mGreenSlider->getValue()) << 8 |
-              static_cast<int>(mBlueSlider->getValue());
-    textColor->setColorAt(mSelected, rgb);
+
+    Palette::ColorType type = guiPalette->getColorTypeAt(mSelected);
+    guiPalette->setColor(type,
+            static_cast<int>(mRedSlider->getValue()),
+            static_cast<int>(mGreenSlider->getValue()),
+            static_cast<int>(mBlueSlider->getValue()));
 }
diff --git a/src/gui/setup_colors.h b/src/gui/setup_colors.h
index 98a2d18b..6cf59b6d 100644
--- a/src/gui/setup_colors.h
+++ b/src/gui/setup_colors.h
@@ -48,6 +48,8 @@ class Setup_Colors : public SetupTab, public gcn::ActionListener,
 
         void listen(const TextField *tf);
     private:
+        static const std::string rawmsg;
+
         gcn::ListBox *mColorBox;
         gcn::ScrollArea *mScroll;
         BrowserBox *mPreview;
diff --git a/src/gui/shoplistbox.cpp b/src/gui/shoplistbox.cpp
index 776f26bc..74209122 100644
--- a/src/gui/shoplistbox.cpp
+++ b/src/gui/shoplistbox.cpp
@@ -23,7 +23,7 @@
 #include <guichan/font.hpp>
 #include <guichan/listmodel.hpp>
 
-#include "color.h"
+#include "palette.h"
 #include "shop.h"
 #include "shoplistbox.h"
 
@@ -64,11 +64,9 @@ void ShopListBox::draw(gcn::Graphics *gcnGraphics)
     if (config.getValue("guialpha", 0.8) != mAlpha)
         mAlpha = config.getValue("guialpha", 0.8);
 
-    bool valid;
-    const int red = (textColor->getColor('H', valid) >> 16) & 0xFF;
-    const int green = (textColor->getColor('H', valid) >> 8) & 0xFF;
-    const int blue = textColor->getColor('H', valid) & 0xFF;
-    const int alpha = (int)(mAlpha * 255.0f);
+    int alpha = (int)(mAlpha * 255.0f);
+    const gcn::Color* highlightColor =
+            &guiPalette->getColor(Palette::HIGHLIGHT, alpha);
 
     Graphics *graphics = static_cast<Graphics*>(gcnGraphics);
 
@@ -79,19 +77,27 @@ void ShopListBox::draw(gcn::Graphics *gcnGraphics)
          i < mListModel->getNumberOfElements();
          ++i, y += mRowHeight)
     {
-        gcn::Color backgroundColor = gcn::Color(255, 255, 255, alpha);
+        gcn::Color temp;
+        const gcn::Color* backgroundColor =
+        &guiPalette->getColor(Palette::BACKGROUND, alpha);
 
-        if (i == mSelected)
-        {
-            backgroundColor = gcn::Color(red, green, blue, alpha);
-        }
-        else if (mShopItems &&
+        if (mShopItems &&
                 mPlayerMoney < mShopItems->at(i)->getPrice() && mPriceCheck)
-        {
-            backgroundColor = gcn::Color(145, 145, 145, alpha);
-        }
+            if (i != mSelected)
+                backgroundColor = &guiPalette->getColor(Palette::SHOP_WARNING,
+                        alpha);
+            else
+            {
+                temp = guiPalette->getColor(Palette::SHOP_WARNING, alpha);
+                temp.r = (temp.r + highlightColor->r) / 2;
+                temp.g = (temp.g + highlightColor->g) / 2;
+                temp.b = (temp.g + highlightColor->b) / 2;
+                backgroundColor = &temp;
+            }
+        else if (i == mSelected)
+            backgroundColor = highlightColor;
 
-        graphics->setColor(backgroundColor);
+        graphics->setColor(*backgroundColor);
         graphics->fillRectangle(gcn::Rectangle(0, y, getWidth(), mRowHeight));
 
         if (mShopItems)
@@ -102,7 +108,7 @@ void ShopListBox::draw(gcn::Graphics *gcnGraphics)
                 graphics->drawImage(icon, 1, y);
             }
         }
-        graphics->setColor(gcn::Color(0, 0, 0));
+        graphics->setColor(guiPalette->getColor(Palette::TEXT));
         graphics->drawText(mListModel->getElementAt(i), ITEM_ICON_SIZE + 5,
                 y + (ITEM_ICON_SIZE - getFont()->getHeight()) / 2);
     }
diff --git a/src/gui/table.cpp b/src/gui/table.cpp
index b2571495..144e7e21 100644
--- a/src/gui/table.cpp
+++ b/src/gui/table.cpp
@@ -24,7 +24,7 @@
 #include <guichan/graphics.hpp>
 #include <guichan/key.hpp>
 
-#include "color.h"
+#include "palette.h"
 #include "table.h"
 
 #include "../configuration.h"
@@ -273,11 +273,8 @@ void GuiTable::draw(gcn::Graphics* graphics)
 
     if (mOpaque)
     {
-        const int red = getBackgroundColor().r;
-        const int green = getBackgroundColor().g;
-        const int blue = getBackgroundColor().b;
-        const int alpha = (int)(mAlpha * 255.0f);
-        graphics->setColor(gcn::Color(red, green, blue, alpha));
+        graphics->setColor(guiPalette->getColor(Palette::BACKGROUND,
+                (int)(mAlpha * 255.0f)));
         graphics->fillRectangle(gcn::Rectangle(0, 0, getWidth(), getHeight()));
     }
 
@@ -324,15 +321,8 @@ void GuiTable::draw(gcn::Graphics* graphics)
 
                 if (!mLinewiseMode && c == mSelectedColumn && r == mSelectedRow)
                 {
-                    bool valid;
-                    const int red = 
-                        (textColor->getColor('H', valid) >> 16) & 0xFF;
-                    const int green =
-                        (textColor->getColor('H', valid) >> 8) & 0xFF;
-                    const int blue = textColor->getColor('H', valid) & 0xFF;
-                    const int alpha = (int)(mAlpha * 127.0f);
-
-                    graphics->setColor(gcn::Color(red, green, blue, alpha));
+                    graphics->setColor(guiPalette->getColor(Palette::HIGHLIGHT,
+                            (int)(mAlpha * 127.0f)));
                     graphics->fillRectangle(bounds);
                 }
 
@@ -346,15 +336,8 @@ void GuiTable::draw(gcn::Graphics* graphics)
 
         if (mLinewiseMode && r == mSelectedRow)
         {
-            bool valid;
-            const int red = 
-                (textColor->getColor('H', valid) >> 16) & 0xFF;
-            const int green =
-                (textColor->getColor('H', valid) >> 8) & 0xFF;
-            const int blue = textColor->getColor('H', valid) & 0xFF;
-            const int alpha = (int)(mAlpha * 127.0f);
-
-            graphics->setColor(gcn::Color(red, green, blue, alpha));
+            graphics->setColor(guiPalette->getColor(Palette::HIGHLIGHT,
+                    (int)(mAlpha * 127.0f)));
             graphics->fillRectangle(gcn::Rectangle(0, y_offset,
                                                    x_offset, height));
         }
diff --git a/src/gui/widgets/dropdown.cpp b/src/gui/widgets/dropdown.cpp
index 7036c2ee..076a167f 100644
--- a/src/gui/widgets/dropdown.cpp
+++ b/src/gui/widgets/dropdown.cpp
@@ -24,8 +24,8 @@
 
 #include "dropdown.h"
 
-#include "../color.h"
 #include "../listbox.h"
+#include "../palette.h"
 #include "../scrollarea.h"
 
 #include "../../configuration.h"
@@ -140,27 +140,24 @@ void DropDown::draw(gcn::Graphics* graphics)
         }
     }
 
-    bool valid;
+//    bool valid;
     const int alpha = (int)(mAlpha * 255.0f);
     gcn::Color faceColor = getBaseColor();
     faceColor.a = alpha;
-    gcn::Color highlightColor = textColor->getColor('H', valid);
-    highlightColor.a = alpha;
+    gcn::Color highlightColor = guiPalette->getColor(Palette::HIGHLIGHT, alpha);
     gcn::Color shadowColor = faceColor - 0x303030;
     shadowColor.a = alpha;
 
     if (mOpaque)
     {
-        int red = getBackgroundColor().r;
-        int green = getBackgroundColor().g;
-        int blue = getBackgroundColor().b;
-        graphics->setColor(gcn::Color(red, green, blue, alpha));
+        gcn::Color col = getBackgroundColor();
+        col.a = alpha;
+        graphics->setColor(col);
         graphics->fillRectangle(gcn::Rectangle(0, 0, getWidth(), h));
 
-        red = getForegroundColor().r;
-        green = getForegroundColor().g;
-        blue = getForegroundColor().b;
-        graphics->setColor(gcn::Color(red, green, blue, alpha));
+        col = getForegroundColor();
+        col.a = alpha;
+        graphics->setColor(col);
     }
 
     graphics->setFont(getFont());
diff --git a/src/main.cpp b/src/main.cpp
index fab7ed95..bed297de 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -56,10 +56,10 @@
 #include "gui/button.h"
 #include "gui/char_server.h"
 #include "gui/char_select.h"
-#include "gui/color.h"
 #include "gui/gui.h"
 #include "gui/login.h"
 #include "gui/ok_dialog.h"
+#include "gui/palette.h"
 #include "gui/progressbar.h"
 #include "gui/register.h"
 #include "gui/sdlinput.h"
@@ -134,7 +134,7 @@ CharServerHandler charServerHandler;
 LoginData loginData;
 LockedArray<LocalPlayer*> charInfo(MAX_SLOT + 1);
 
-Color *textColor;
+Palette *guiPalette;
 
 // This anonymous namespace hides whatever is inside from other modules.
 namespace {
@@ -767,7 +767,7 @@ int main(int argc, char *argv[])
     unsigned int oldstate = !state; // We start with a status change.
 
     // Needs to be created in main, as the updater uses it
-    textColor = new Color();
+    guiPalette = new Palette;
 
     Game *game = NULL;
     Window *currentDialog = NULL;
@@ -1108,7 +1108,7 @@ int main(int argc, char *argv[])
         usleep(50000);
     }
 
-    delete textColor;
+    delete guiPalette;
 #ifdef PACKAGE_VERSION
     delete versionLabel;
 #endif
diff --git a/src/text.cpp b/src/text.cpp
index c167701a..2d96152b 100644
--- a/src/text.cpp
+++ b/src/text.cpp
@@ -80,7 +80,7 @@ void Text::draw(gcn::Graphics *graphics, int xOff, int yOff)
 
     TextRenderer::renderText(graphics, mText,
             mX - xOff, mY - yOff, gcn::Graphics::LEFT,
-            &mColor, boldFont, !mIsSpeech, true);
+            &mColor, boldFont, true, true);
 }
 
 FlashText::FlashText(const std::string &text, int x, int y,