UserPalette Class Reference

#include <userpalette.h>

Inheritance diagram for UserPalette:

Public Member Functions
	UserPalette ()
	~UserPalette ()
const Color &	getCommittedColor (const UserColorIdT type) const
const Color &	getTestColor (const UserColorIdT type) const
void	setTestColor (const UserColorIdT type, const Color &color)
void	setColor (const UserColorIdT type, const int r, const int g, const int b)
void	setGradient (const UserColorIdT type, const GradientTypeT grad)
void	setGradientDelay (const UserColorIdT type, const int delay)
int	getNumberOfElements ()
std::string	getElementAt (int i)
void	commit ()
void	rollback ()
int	getColorTypeAt (const int i)
const Color &	getColor (UserColorIdT type, const unsigned int alpha)
int	getIdByChar (const signed char c, bool &valid) const
GradientTypeT	getGradientType (const UserColorIdT type) const
int	getGradientDelay (const UserColorIdT type) const
const Color &	getColorWithAlpha (const UserColorIdT type)
Public Member Functions inherited from Palette
const Color &	getCharColor (const signed char c, bool &valid) const
char	getColorChar (const int type) const
Public Member Functions inherited from ListModel
	ListModel ()
virtual	~ListModel ()

Private Member Functions
void	setColorAt (int i, int r, int g, int b)
void	commit (const bool commitNonStatic)
void	addColor (const UserColorIdT type, const unsigned rgb, GradientTypeT grad, const std::string &text, int delay)
void	addLabel (const UserColorIdT type, const std::string &text)

Static Private Member Functions
static std::string	getConfigName (const std::string &typeName)

Additional Inherited Members
Static Public Member Functions inherited from Palette
static void	advanceGradients ()
Static Public Attributes inherited from Palette
static const Color	BLACK = Color(0, 0, 0, 255)
Protected Types inherited from Palette
typedef std::set< Palette * >	Palettes
typedef std::vector< ColorElem >	Colors
typedef std::map< unsigned char, int >	CharColors
Protected Member Functions inherited from Palette
	Palette (const int size)
virtual	~Palette ()
void	advanceGradient ()
Protected Attributes inherited from Palette
int	mRainbowTime
Colors	mColors
CharColors	mCharColors
std::vector< ColorElem * >	mGradVector
Static Protected Attributes inherited from Palette
static const Color	RAINBOW_COLORS [7]
static const int	RAINBOW_COLOR_COUNT = 7
static Palettes	mInstances

Detailed Description

Class controlling the game's color palette.

Definition at line 39 of file userpalette.h.

Constructor & Destructor Documentation

UserPalette()

UserPalette::UserPalette

(

)

Constructor

Definition at line 128 of file userpalette.cpp.

                         :
    Palette(CAST_S32(UserColorId::USER_COLOR_LAST)),
    ListModel()
{
    mColors[CAST_SIZE(UserColorId::BEING)] = ColorElem();
    mColors[CAST_SIZE(UserColorId::PC)] = ColorElem();
    mColors[CAST_SIZE(UserColorId::SELF)] = ColorElem();
    mColors[CAST_SIZE(UserColorId::GM)] = ColorElem();
    mColors[CAST_SIZE(UserColorId::NPC)] = ColorElem();
    mColors[CAST_SIZE(UserColorId::MONSTER)] = ColorElem();
 
    addLabel(UserColorId::LABEL_BEING,
        // TRANSLATORS: palette label
        _("Beings"));
    addColor(UserColorId::BEING,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Being"),
        GRADIENT_DELAY);
    addColor(UserColorId::FRIEND,
        0xb0ffb0,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Friend names"),
        GRADIENT_DELAY);
    addColor(UserColorId::DISREGARDED,
        0xa00000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Disregarded names"),
        GRADIENT_DELAY);
    addColor(UserColorId::IGNORED,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Ignored names"),
        GRADIENT_DELAY);
    addColor(UserColorId::ERASED,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Erased names"),
        GRADIENT_DELAY);
    addColor(UserColorId::ENEMY,
        0xff4040,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Enemy"),
        GRADIENT_DELAY);
    addColor(UserColorId::PC,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Other players names"),
        GRADIENT_DELAY);
    addColor(UserColorId::SELF,
        0xff8040,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Own name"),
        GRADIENT_DELAY);
    addColor(UserColorId::GM,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("GM names"),
        GRADIENT_DELAY);
    addColor(UserColorId::NPC,
        0xc8c8ff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("NPCs"),
        GRADIENT_DELAY);
    addColor(UserColorId::MONSTER,
        0xff4040,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monsters"),
        GRADIENT_DELAY);
    addColor(UserColorId::PET,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Pets"),
        GRADIENT_DELAY);
    addColor(UserColorId::MERCENARY,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Mercenary"),
        GRADIENT_DELAY);
    addColor(UserColorId::HOMUNCULUS,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Homunculus"),
        GRADIENT_DELAY);
    addColor(UserColorId::SKILLUNIT,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Skill unit"),
        GRADIENT_DELAY);
    addColor(UserColorId::PARTY,
        0xff00d8,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Party members"),
        GRADIENT_DELAY);
    addColor(UserColorId::GUILD,
        0xff00d8,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Guild members"),
        GRADIENT_DELAY);
    addColor(UserColorId::TEAM1,
        0x0000ff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        strprintf(_("Team %d"), 1),
        GRADIENT_DELAY);
    addColor(UserColorId::TEAM2,
        0x00a020,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        strprintf(_("Team %d"), 2),
        GRADIENT_DELAY);
    addColor(UserColorId::TEAM3,
        0xffff20,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        strprintf(_("Team %d"), 3),
        GRADIENT_DELAY);
    addLabel(UserColorId::LABEL_PARTICLES,
        // TRANSLATORS: palette label
        _("Particles"));
    addColor(UserColorId::PARTICLE,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Particle effects"),
        GRADIENT_DELAY);
    addColor(UserColorId::PICKUP_INFO,
        0x28dc28,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Pickup notification"),
        GRADIENT_DELAY);
    addColor(UserColorId::EXP_INFO,
        0xffff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Exp notification"),
        GRADIENT_DELAY);
    addLabel(UserColorId::LABEL_HP,
        // TRANSLATORS: palette label
        _("Hp bars"));
    addColor(UserColorId::PLAYER_HP,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Player HP bar"), 50);
    addColor(UserColorId::PLAYER_HP2,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Player HP bar (second color)"),
        50);
    addColor(UserColorId::MONSTER_HP,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monster HP bar"),
        50);
    addColor(UserColorId::MONSTER_HP2,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monster HP bar (second color)"),
        50);
    addColor(UserColorId::HOMUN_HP,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Homunculus HP bar"),
        50);
    addColor(UserColorId::HOMUN_HP2,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Homunculus HP bar (second color)"),
        50);
    addColor(UserColorId::MERC_HP,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Mercenary HP bar"),
        50);
    addColor(UserColorId::MERC_HP2,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Mercenary HP bar (second color)"),
        50);
 
    addColor(UserColorId::ELEMENTAL_HP,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Elemental HP bar"),
        50);
    addColor(UserColorId::ELEMENTAL_HP2,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Elemental HP bar (second color)"),
        50);
    addLabel(UserColorId::LABEL_HITS,
        // TRANSLATORS: palette label
        _("Hits"));
    addColor(UserColorId::HIT_PLAYER_MONSTER,
        0x0064ff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Player hits monster"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_MONSTER_PLAYER,
        0xff3232,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monster hits player"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_PLAYER_PLAYER,
        0xff5050,
        GradientType::STATIC,
       // TRANSLATORS: palette color
       _("Other player hits local player"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_CRITICAL,
        0xff0000,
        GradientType::RAINBOW,
        // TRANSLATORS: palette color
        _("Critical Hit"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_LOCAL_PLAYER_MONSTER,
        0x00ff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Local player hits monster"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_LOCAL_PLAYER_CRITICAL,
        0xff0000,
        GradientType::RAINBOW,
        // TRANSLATORS: palette color
        _("Local player critical hit"),
        GRADIENT_DELAY);
    addColor(UserColorId::HIT_LOCAL_PLAYER_MISS,
        0x00ffa6,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Local player miss"),
        GRADIENT_DELAY);
    addColor(UserColorId::MISS, 0xffff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Misses"),
        GRADIENT_DELAY);
    addLabel(UserColorId::LABEL_TILES,
        // TRANSLATORS: palette label
        _("Tiles"));
    addColor(UserColorId::PORTAL_HIGHLIGHT,
        0xC80000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Portal highlight"),
        GRADIENT_DELAY);
    addColor(UserColorId::COLLISION_HIGHLIGHT,
        0x0000C8,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Default collision highlight"),
        64);
    addColor(UserColorId::AIR_COLLISION_HIGHLIGHT,
        0xe0e0ff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Air collision highlight"),
        64);
    addColor(UserColorId::WATER_COLLISION_HIGHLIGHT,
        0x2050e0,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Water collision highlight"),
        64);
    addColor(UserColorId::MONSTER_COLLISION_HIGHLIGHT,
        0x2050e0,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monster collision highlight"),
        64);
    addColor(UserColorId::GROUNDTOP_COLLISION_HIGHLIGHT,
        0xffff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Special ground collision highlight"),
        20);
    addColor(UserColorId::WALKABLE_HIGHLIGHT,
        0x00D000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Walkable highlight"),
        255);
    addColor(UserColorId::NET,
        0x000000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Tiles border"), 64);
    addLabel(UserColorId::LABEL_RANGES,
        // TRANSLATORS: palette label
        _("Ranges"));
    addColor(UserColorId::ATTACK_RANGE,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Local player attack range"),
        5);
    addColor(UserColorId::ATTACK_RANGE_BORDER,
        0x0,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Local player attack range border"),
        76);
    addColor(UserColorId::MONSTER_ATTACK_RANGE,
        0xff0000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Monster attack range"),
        20);
    addColor(UserColorId::SKILL_ATTACK_RANGE,
        0x0,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Skill attack range border"),
        76);
    addLabel(UserColorId::LABEL_OTHER,
        // TRANSLATORS: palette label
        _("Other"));
    addColor(UserColorId::FLOOR_ITEM_TEXT,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Floor item amount color"),
        100);
    addColor(UserColorId::HOME_PLACE,
        0xffffff,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Home place"),
        20);
    addColor(UserColorId::HOME_PLACE_BORDER,
        0xffff00,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Home place border"),
        200);
    addColor(UserColorId::ROAD_POINT,
        0x000000,
        GradientType::STATIC,
        // TRANSLATORS: palette color
        _("Road point"), 100);
    commit(true);
}

References _, addColor(), addLabel(), UserColorId::AIR_COLLISION_HIGHLIGHT, UserColorId::ATTACK_RANGE, UserColorId::ATTACK_RANGE_BORDER, UserColorId::BEING, CAST_SIZE, UserColorId::COLLISION_HIGHLIGHT, commit(), UserColorId::DISREGARDED, UserColorId::ELEMENTAL_HP, UserColorId::ELEMENTAL_HP2, UserColorId::ENEMY, UserColorId::ERASED, UserColorId::EXP_INFO, UserColorId::FLOOR_ITEM_TEXT, UserColorId::FRIEND, UserColorId::GM, GRADIENT_DELAY, UserColorId::GROUNDTOP_COLLISION_HIGHLIGHT, UserColorId::GUILD, UserColorId::HIT_CRITICAL, UserColorId::HIT_LOCAL_PLAYER_CRITICAL, UserColorId::HIT_LOCAL_PLAYER_MISS, UserColorId::HIT_LOCAL_PLAYER_MONSTER, UserColorId::HIT_MONSTER_PLAYER, UserColorId::HIT_PLAYER_MONSTER, UserColorId::HIT_PLAYER_PLAYER, UserColorId::HOME_PLACE, UserColorId::HOME_PLACE_BORDER, UserColorId::HOMUN_HP, UserColorId::HOMUN_HP2, UserColorId::HOMUNCULUS, UserColorId::IGNORED, UserColorId::LABEL_BEING, UserColorId::LABEL_HITS, UserColorId::LABEL_HP, UserColorId::LABEL_OTHER, UserColorId::LABEL_PARTICLES, UserColorId::LABEL_RANGES, UserColorId::LABEL_TILES, Palette::mColors, UserColorId::MERC_HP, UserColorId::MERC_HP2, UserColorId::MERCENARY, UserColorId::MISS, UserColorId::MONSTER, UserColorId::MONSTER_ATTACK_RANGE, UserColorId::MONSTER_COLLISION_HIGHLIGHT, UserColorId::MONSTER_HP, UserColorId::MONSTER_HP2, UserColorId::NET, UserColorId::NPC, UserColorId::PARTICLE, UserColorId::PARTY, UserColorId::PC, UserColorId::PET, UserColorId::PICKUP_INFO, UserColorId::PLAYER_HP, UserColorId::PLAYER_HP2, UserColorId::PORTAL_HIGHLIGHT, GradientType::RAINBOW, UserColorId::ROAD_POINT, UserColorId::SELF, UserColorId::SKILL_ATTACK_RANGE, UserColorId::SKILLUNIT, GradientType::STATIC, strprintf(), UserColorId::TEAM1, UserColorId::TEAM2, UserColorId::TEAM3, UserColorId::WALKABLE_HIGHLIGHT, and UserColorId::WATER_COLLISION_HIGHLIGHT.

~UserPalette()

UserPalette::~UserPalette

(

)

Destructor

Definition at line 502 of file userpalette.cpp.

{
    FOR_EACH (Colors::const_iterator, col, mColors)
    {
        if (col->grad == GradientType::LABEL)
            continue;
        const std::string &configName = ColorTypeNames[col->type];
        config.setValue(configName + "Gradient",
            CAST_S32(col->committedGrad));
        config.setValue(configName + "Delay", col->delay);
 
        if (col->grad == GradientType::STATIC ||
            col->grad == GradientType::PULSE)
        {
            char buffer[20];
            snprintf(buffer, sizeof(buffer), "0x%06x", col->getRGB());
            buffer[19] = 0;
            config.setValue(configName, std::string(buffer));
        }
    }
}

References CAST_S32, ColorTypeNames, config, FOR_EACH, GradientType::LABEL, Palette::mColors, GradientType::PULSE, Configuration::setValue(), and GradientType::STATIC.

Member Function Documentation

addColor()

void UserPalette::addColor ( const UserColorIdT  type, const unsigned  rgb, GradientTypeT  grad, const std::string &  text, int  delay  )

private

Definition at line 616 of file userpalette.cpp.

{
    const unsigned maxType = sizeof(ColorTypeNames)
        / sizeof(ColorTypeNames[0]);
 
    if (CAST_U32(type) >= maxType)
        return;
 
    const std::string &configName = ColorTypeNames[CAST_SIZE(type)];
    char buffer[20];
    snprintf(buffer, sizeof(buffer), "0x%06x", rgb);
    buffer[19] = 0;
 
    const std::string rgbString = config.getValue(
        configName, std::string(buffer));
    unsigned int rgbValue = 0;
    if (rgbString.length() == 8 && rgbString[0] == '0' && rgbString[1] == 'x')
        rgbValue = atox(rgbString);
    else
        rgbValue = atoi(rgbString.c_str());
    const Color &trueCol = Color(rgbValue);
    grad = static_cast<GradientTypeT>(config.getValue(
        configName + "Gradient",
        CAST_S32(grad)));
    delay = config.getValueInt(configName + "Delay", delay);
    mColors[CAST_SIZE(type)].set(CAST_S32(type),
        trueCol, grad, delay);
    mColors[CAST_SIZE(type)].text = text;
 
    if (grad != GradientType::STATIC)
        mGradVector.push_back(&mColors[CAST_SIZE(type)]);
}

References atox(), CAST_S32, CAST_SIZE, CAST_U32, ColorTypeNames, config, ConfigurationObject::getValue(), ConfigurationObject::getValueInt(), Palette::mColors, Palette::mGradVector, and GradientType::STATIC.

Referenced by UserPalette().

addLabel()

void UserPalette::addLabel ( const UserColorIdT  type, const std::string &  text  )

private

Definition at line 653 of file userpalette.cpp.

{
    const unsigned maxType = sizeof(ColorTypeNames)
        / sizeof(ColorTypeNames[0]);
 
    if (CAST_U32(type) >= maxType)
        return;
 
 
    mColors[CAST_SIZE(type)] = ColorElem();
    const std::string str(" \342\200\225\342\200\225\342\200\225"
        "\342\200\225\342\200\225 ");
    mColors[CAST_SIZE(type)].grad = GradientType::LABEL;
    mColors[CAST_SIZE(type)].text =
        std::string(str).append(text).append(str);
}

References CAST_SIZE, CAST_U32, ColorTypeNames, GradientType::LABEL, and Palette::mColors.

Referenced by UserPalette().

commit() [1/2]

void UserPalette::commit ( )

inline

Commit the colors

Definition at line 133 of file userpalette.h.

        { commit(false); }

Referenced by Setup_Colors::apply(), and UserPalette().

commit() [2/2]

void UserPalette::commit ( const bool  commitNonStatic )

private

Commit the colors. Commit the non-static color values, if commitNonStatic is true. Only needed in the constructor.

Definition at line 570 of file userpalette.cpp.

{
    FOR_EACH (Colors::iterator, i, mColors)
    {
        i->committedGrad = i->grad;
        i->committedDelay = i->delay;
        if (commitNonStatic || i->grad == GradientType::STATIC)
            i->committedColor = i->color;
        else if (i->grad == GradientType::PULSE)
            i->committedColor = i->testColor;
    }
}

References FOR_EACH, Palette::mColors, GradientType::PULSE, and GradientType::STATIC.

getColor()

const Color& UserPalette::getColor ( UserColorIdT  type, const unsigned int  alpha  )

inline

Gets the color associated with the type. Sets the alpha channel before returning.

Parameters

type	the color type requested
alpha	alpha channel to use

Returns

the requested color

Definition at line 160 of file userpalette.h.

        {
            if (CAST_SIZE(type) >= mColors.size())
            {
                logger->log("incorrect color request type: %d from %u",
                    CAST_S32(type),
                    CAST_U32(mColors.size()));
                type = UserColorId::BEING;
            }
            Color* col = &mColors[CAST_SIZE(type)].color;
            col->a = alpha;
            return *col;
        }

References Color::a, UserColorId::BEING, CAST_S32, CAST_SIZE, CAST_U32, Logger::log(), logger, and Palette::mColors.

Referenced by Setup_Colors::cancel(), FloorItem::draw(), MapItem::draw(), Minimap::draw2(), Being::drawPortalSpriteAt(), LocalPlayer::LocalPlayer(), LocalPlayer::logic(), Being::setDefaultNameColor(), Being::setSpeech(), Being::takeDamage(), Being::updateColors(), and Setup_Colors::valueChanged().

getColorTypeAt()

int UserPalette::getColorTypeAt

(

const int

i

)

Gets the ColorType used by the color for the element at index i in the current color model.

Parameters

i	the index of the color

Returns

the color type of the color with the given index

Definition at line 608 of file userpalette.cpp.

{
    if (i < 0 || i >= getNumberOfElements())
        return 0;
 
    return mColors[i].type;
}

References getNumberOfElements(), and Palette::mColors.

Referenced by Setup_Colors::cancel(), Setup_Colors::updateColor(), Setup_Colors::updateGradType(), and Setup_Colors::valueChanged().

getColorWithAlpha()

const Color& UserPalette::getColorWithAlpha ( const UserColorIdT  type )

inline

Definition at line 200 of file userpalette.h.

        {
            Color *const col = &mColors[CAST_SIZE(type)].color;
            col->a = CAST_U32(
                mColors[CAST_SIZE(type)].delay);
            return *col;
        }

References Color::a, CAST_SIZE, CAST_U32, and Palette::mColors.

Referenced by CastingEffect::draw(), MapItem::draw(), Map::draw(), Map::drawCollision(), Being::drawElementalSpriteAt(), MapLayer::drawFringe(), Being::drawHomunculusSpriteAt(), Being::drawHpBar(), Being::drawMercenarySpriteAt(), and Being::drawMonsterSpriteAt().

getCommittedColor()

const Color& UserPalette::getCommittedColor ( const UserColorIdT  type ) const

inline

Gets the committed color associated with the specified type.

Parameters

type	the color type requested

Returns

the requested committed color

Definition at line 61 of file userpalette.h.

        {
            return mColors[CAST_SIZE(type)].committedColor;
        }

References CAST_SIZE, and Palette::mColors.

Referenced by Setup_Colors::valueChanged().

getConfigName()

std::string UserPalette::getConfigName ( const std::string &  typeName )

staticprivate

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

Parameters

typeName

string to transform

Returns

the transformed string

Definition at line 105 of file userpalette.cpp.

{
    std::string res("Color" + typeName);
    size_t pos = 5;
    for (size_t i = 0; i < typeName.length(); i++)
    {
        if (i == 0 || typeName[i] == '_')
        {
            if (i > 0)
                i++;
 
            res[pos] = typeName[i];
        }
        else
        {
           res[pos] = CAST_S8(tolower(typeName[i]));
        }
        pos ++;
    }
    res.erase(pos, res.length() - pos);
    return res;
}

References CAST_S8.

getElementAt()

std::string UserPalette::getElementAt ( int  i )

virtual

Returns the name of the ith color.

Parameters

i	index of color interested in

Returns

the name of the color

Implements ListModel.

Definition at line 562 of file userpalette.cpp.

{
    if (i < 0 || i >= getNumberOfElements())
        return "";
 
    return mColors[i].text;
}

References getNumberOfElements(), and Palette::mColors.

getGradientDelay()

int UserPalette::getGradientDelay ( const UserColorIdT  type ) const

inline

Gets the gradient delay for the specified type.

Parameters

type	the color type of the color

Returns

the gradient delay of the color with the given index

Definition at line 196 of file userpalette.h.

        { return mColors[CAST_SIZE(type)].delay; }

References CAST_SIZE, and Palette::mColors.

Referenced by Setup_Colors::cancel(), and Setup_Colors::valueChanged().

getGradientType()

GradientTypeT UserPalette::getGradientType ( const UserColorIdT  type ) const

inline

Gets the GradientType associated with the specified type.

Parameters

type	the color type of the color

Returns

the gradient type of the color with the given index

Definition at line 185 of file userpalette.h.

        { return mColors[CAST_SIZE(type)].grad; }

References CAST_SIZE, and Palette::mColors.

Referenced by Setup_Colors::cancel(), Setup_Colors::updateGradType(), and Setup_Colors::valueChanged().

getIdByChar()

int UserPalette::getIdByChar	(	const signed char	c,
		bool &	valid
	)		const

Definition at line 671 of file userpalette.cpp.

{
    const CharColors::const_iterator it = mCharColors.find(c);
    if (it != mCharColors.end())
    {
        valid = true;
        return (*it).second;
    }
 
    valid = false;
    return 0;
}

References Palette::mCharColors, and anonymous_namespace{libxml.cpp}::valid.

getNumberOfElements()

int UserPalette::getNumberOfElements ( )

inlinevirtual

Returns the number of colors known.

Returns

the number of colors known

Implements ListModel.

Definition at line 118 of file userpalette.h.

        { return CAST_S32(mColors.size()); }

References CAST_S32, and Palette::mColors.

Referenced by getColorTypeAt(), and getElementAt().

getTestColor()

const Color& UserPalette::getTestColor ( const UserColorIdT  type ) const

inline

Gets the test color associated with the specified type.

Parameters

type	the color type requested

Returns

the requested test color

Definition at line 74 of file userpalette.h.

        { return mColors[CAST_SIZE(type)].testColor; }

References CAST_SIZE, and Palette::mColors.

Referenced by Setup_Colors::valueChanged().

rollback()

void UserPalette::rollback

(

)

Rollback the colors

Definition at line 583 of file userpalette.cpp.

{
    FOR_EACH (Colors::iterator, i, mColors)
    {
        if (i->grad != i->committedGrad)
            setGradient(static_cast<UserColorIdT>(i->type), i->committedGrad);
 
        const Color &committedColor = i->committedColor;
        setGradientDelay(static_cast<UserColorIdT>(i->type),
            i->committedDelay);
        setColor(static_cast<UserColorIdT>(i->type),
            committedColor.r,
            committedColor.g,
            committedColor.b);
 
        if (i->grad == GradientType::PULSE)
        {
            Color &testColor = i->testColor;
            testColor.r = committedColor.r;
            testColor.g = committedColor.g;
            testColor.b = committedColor.b;
        }
    }
}

References Color::b, FOR_EACH, Color::g, Palette::mColors, GradientType::PULSE, Color::r, setColor(), setGradient(), and setGradientDelay().

Referenced by Setup_Colors::cancel().

setColor()

void UserPalette::setColor	(	const UserColorIdT	type,
		const int	r,
		const int	g,
		const int	b
	)

Sets the color for the specified type.

Parameters

type	color to be set
r	red component
g	green component
b	blue component

Definition at line 524 of file userpalette.cpp.

{
    Color &color = mColors[CAST_SIZE(type)].color;
    color.r = r;
    color.g = g;
    color.b = b;
}

References Color::b, CAST_SIZE, Color::g, Palette::mColors, and Color::r.

Referenced by rollback(), and Setup_Colors::updateColor().

setColorAt()

void UserPalette::setColorAt ( int  i, int  r, int  g, int  b  )

private

Define a color replacement.

Parameters

i	the index of the color to replace
r	red component
g	green component
b	blue component

setGradient()

void UserPalette::setGradient	(	const UserColorIdT	type,
		const GradientTypeT	grad
	)

Sets the gradient type for the specified color.

Parameters

grad	gradient type to set

Definition at line 535 of file userpalette.cpp.

{
    ColorElem *const elem = &mColors[CAST_SIZE(type)];
 
    if (elem->grad != GradientType::STATIC && grad == GradientType::STATIC)
    {
        const size_t sz = mGradVector.size();
        for (size_t i = 0; i < sz; i++)
        {
            if (mGradVector[i] == elem)
            {
                mGradVector.erase(mGradVector.begin() + i);
                break;
            }
        }
    }
    else if (elem->grad == GradientType::STATIC &&
             grad != GradientType::STATIC)
    {
        mGradVector.push_back(elem);
    }
 
    if (elem->grad != grad)
        elem->grad = grad;
}

References CAST_SIZE, Palette::ColorElem::grad, Palette::mColors, Palette::mGradVector, and GradientType::STATIC.

Referenced by rollback(), and Setup_Colors::updateColor().

setGradientDelay()

void UserPalette::setGradientDelay ( const UserColorIdT  type, const int  delay  )

inline

Definition at line 109 of file userpalette.h.

        { mColors[CAST_SIZE(type)].delay = delay; }

References CAST_SIZE, and Palette::mColors.

Referenced by rollback(), and Setup_Colors::updateColor().

setTestColor()

void UserPalette::setTestColor ( const UserColorIdT  type, const Color &  color  )

inline

Sets the test color associated with the specified type.

Parameters

type	the color type requested
color	the color that should be tested

Definition at line 84 of file userpalette.h.

        { mColors[CAST_SIZE(type)].testColor = color; }

References CAST_SIZE, and Palette::mColors.

Referenced by Setup_Colors::updateColor().

---

The documentation for this class was generated from the following files:

• src/gui/userpalette.h (986a3bf)
• src/gui/userpalette.cpp (986a3bf)