Theme Class Reference

#include <theme.h>

Inheritance diagram for Theme:

Public Member Functions
	Theme ()
	~Theme ()
Skin *	load (const std::string &filename, const std::string &filename2, const bool full, const std::string &defaultPath)
Skin *	loadSkinRect (ImageRect &image, const std::string &name, const std::string &name2, const int start, const int end)
void	unload (Skin *const skin)
void	updateAlpha ()
float	getMinimumOpacity () const
const Color &	getColor (const ThemeColorIdT type, const unsigned int alpha)
ThemeColorIdT	getIdByChar (const signed char c, bool &valid) const
void	setMinimumOpacity (const float minimumOpacity)
void	optionChanged (const std::string &name)
void	loadRect (ImageRect &image, const std::string &name, const std::string &name2, const int start, const int end)
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 ConfigListener
	ConfigListener ()
virtual	~ConfigListener ()

Static Public Member Functions
static void	prepareThemePath ()
static void	selectSkin ()
static std::string	getThemePath ()
static std::string	getThemeName ()
static void	fillSkinsList (StringVect &list)
static void	fillFontsList (StringVect &list)
static void	fillSoundsList (StringVect &list)
static std::string	resolveThemePath (const std::string &path)
static Image *	getImageFromTheme (const std::string &path)
static ImageSet *	getImageSetFromTheme (const std::string &path, const int w, const int h)
static ImageSet *	getImageSetFromThemeXml (const std::string &name, const std::string &name2, const int w, const int h)
static Color	getProgressColor (const ProgressColorIdT type, const float progress)
static void	unloadRect (const ImageRect &rect, const int start, const int end)
static Image *	getImageFromThemeXml (const std::string &name, const std::string &name2)
static ThemeInfo *	loadInfo (const std::string &themeName)
Static Public Member Functions inherited from Palette
static void	advanceGradients ()

Private Types
typedef std::map< std::string, Skin * >	Skins
typedef Skins::iterator	SkinIterator
typedef std::vector< DyePalette * >	ProgressColors

Private Member Functions
Skin *	readSkin (const std::string &filename0, const bool full)
void	loadColors (std::string file)

Static Private Member Functions
static bool	tryThemePath (const std::string &themePath)

Private Attributes
Skins	mSkins
float	mMinimumOpacity
ProgressColors	mProgressColors

Static Private Attributes
static std::string	mThemePath
static std::string	mThemeName
static std::string	mScreenDensity

Additional Inherited Members
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

Definition at line 53 of file theme.h.

Member Typedef Documentation

ProgressColors

typedef std::vector<DyePalette*> Theme::ProgressColors

private

Definition at line 208 of file theme.h.

SkinIterator

typedef Skins::iterator Theme::SkinIterator

private

Definition at line 190 of file theme.h.

Skins

typedef std::map<std::string, Skin*> Theme::Skins

private

Definition at line 189 of file theme.h.

Constructor & Destructor Documentation

Theme()

Theme::Theme

(

)

Definition at line 78 of file theme.cpp.

             :
    Palette(CAST_S32(ThemeColorId::THEME_COLORS_END) * THEME_PALETTES),
    mSkins(),
    mMinimumOpacity(-1.0F),
    mProgressColors(ProgressColors(CAST_SIZE(
                    ProgressColorId::THEME_PROG_END)))
{
    initDefaultThemePath();
 
    config.addListener("guialpha", this);
 
    mColors[CAST_SIZE(ThemeColorId::HIGHLIGHT)].ch = 'H';
    mColors[CAST_SIZE(ThemeColorId::CHAT)].ch = 'C';
    mColors[CAST_SIZE(ThemeColorId::GM)].ch = 'G';
    mColors[CAST_SIZE(ThemeColorId::GLOBAL)].ch = 'g';
    mColors[CAST_SIZE(ThemeColorId::PLAYER)].ch = 'Y';
    mColors[CAST_SIZE(ThemeColorId::WHISPER_TAB)].ch = 'W';
    mColors[CAST_SIZE(ThemeColorId::WHISPER_TAB_OFFLINE)].ch = 'w';
    mColors[CAST_SIZE(ThemeColorId::IS)].ch = 'I';
    mColors[CAST_SIZE(ThemeColorId::PARTY_CHAT_TAB)].ch = 'P';
    mColors[CAST_SIZE(ThemeColorId::GUILD_CHAT_TAB)].ch = 'U';
    mColors[CAST_SIZE(ThemeColorId::SERVER)].ch = 'S';
    mColors[CAST_SIZE(ThemeColorId::LOGGER)].ch = 'L';
    mColors[CAST_SIZE(ThemeColorId::HYPERLINK)].ch = '<';
    mColors[CAST_SIZE(ThemeColorId::SELFNICK)].ch = 's';
    mColors[CAST_SIZE(ThemeColorId::OLDCHAT)].ch = 'o';
    mColors[CAST_SIZE(ThemeColorId::AWAYCHAT)].ch = 'a';
    mCharColors['H'] = CAST_S32(ThemeColorId::HIGHLIGHT);
    mCharColors['C'] = CAST_S32(ThemeColorId::CHAT);
    mCharColors['G'] = CAST_S32(ThemeColorId::GM);
    mCharColors['g'] = CAST_S32(ThemeColorId::GLOBAL);
    mCharColors['Y'] = CAST_S32(ThemeColorId::PLAYER);
    mCharColors['W'] = CAST_S32(ThemeColorId::WHISPER_TAB);
    mCharColors['w'] = CAST_S32(ThemeColorId::WHISPER_TAB_OFFLINE);
    mCharColors['I'] = CAST_S32(ThemeColorId::IS);
    mCharColors['P'] = CAST_S32(ThemeColorId::PARTY_CHAT_TAB);
    mCharColors['U'] = CAST_S32(ThemeColorId::GUILD_CHAT_TAB);
    mCharColors['S'] = CAST_S32(ThemeColorId::SERVER);
    mCharColors['L'] = CAST_S32(ThemeColorId::LOGGER);
    mCharColors['<'] = CAST_S32(ThemeColorId::HYPERLINK);
    mCharColors['s'] = CAST_S32(ThemeColorId::SELFNICK);
    mCharColors['o'] = CAST_S32(ThemeColorId::OLDCHAT);
    mCharColors['a'] = CAST_S32(ThemeColorId::AWAYCHAT);
 
    // here need use outlined colors
    mCharColors['H' | 0x80]
        = CAST_S32(ThemeColorId::HIGHLIGHT_OUTLINE);
    mCharColors['C' | 0x80] = CAST_S32(ThemeColorId::CHAT_OUTLINE);
    mCharColors['G' | 0x80] = CAST_S32(ThemeColorId::GM_OUTLINE);
    mCharColors['g' | 0x80] = CAST_S32(ThemeColorId::GLOBAL_OUTLINE);
    mCharColors['Y' | 0x80] = CAST_S32(ThemeColorId::PLAYER_OUTLINE);
    mCharColors['W' | 0x80]
        = CAST_S32(ThemeColorId::WHISPER_TAB_OUTLINE);
    mCharColors['w' | 0x80]
        = CAST_S32(ThemeColorId::WHISPER_TAB_OFFLINE_OUTLINE);
    mCharColors['I' | 0x80] = CAST_S32(ThemeColorId::IS_OUTLINE);
    mCharColors['P' | 0x80]
        = CAST_S32(ThemeColorId::PARTY_CHAT_TAB_OUTLINE);
    mCharColors['U' | 0x80]
        = CAST_S32(ThemeColorId::GUILD_CHAT_TAB_OUTLINE);
    mCharColors['S' | 0x80] = CAST_S32(ThemeColorId::SERVER_OUTLINE);
    mCharColors['L' | 0x80] = CAST_S32(ThemeColorId::LOGGER_OUTLINE);
    mCharColors['<' | 0x80]
        = CAST_S32(ThemeColorId::HYPERLINK_OUTLINE);
    mCharColors['s' | 0x80] = CAST_S32(ThemeColorId::SELFNICK_OUTLINE);
    mCharColors['o' | 0x80] = CAST_S32(ThemeColorId::OLDCHAT_OUTLINE);
    mCharColors['a' | 0x80] = CAST_S32(ThemeColorId::AWAYCHAT_OUTLINE);
}

References Configuration::addListener(), CAST_S32, CAST_SIZE, BeingType::CHAT, config, BeingFlag::GM, initDefaultThemePath(), Palette::mCharColors, and Palette::mColors.

~Theme()

Theme::~Theme

(

)

Definition at line 147 of file theme.cpp.

{
    delete_all(mSkins);
    config.removeListener("guialpha", this);
    CHECKLISTENERS
    delete_all(mProgressColors);
}

References CHECKLISTENERS, config, delete_all(), mProgressColors, mSkins, and Configuration::removeListener().

Member Function Documentation

fillFontsList()

void Theme::fillFontsList ( StringVect &  list )

static

Definition at line 570 of file theme.cpp.

{
    VirtFs::permitLinks(true);
    VirtFs::getFiles(branding.getStringValue("fontsPath"), list);
    std::sort(list.begin(), list.end());
    VirtFs::permitLinks(false);
}

References branding, VirtFs::getFiles(), Configuration::getStringValue(), and VirtFs::permitLinks().

Referenced by FontsModel::FontsModel().

fillSkinsList()

void Theme::fillSkinsList ( StringVect &  list )

static

Definition at line 564 of file theme.cpp.

{
    VirtFs::getDirs(branding.getStringValue("guiThemePath"), list);
    std::sort(list.begin(), list.end());
}

References branding, VirtFs::getDirs(), and Configuration::getStringValue().

Referenced by ThemesModel::ThemesModel().

fillSoundsList()

void Theme::fillSoundsList ( StringVect &  list )

static

Definition at line 578 of file theme.cpp.

{
    VirtFs::List *const skins = VirtFs::enumerateFiles(
        branding.getStringValue("systemsounds"));
 
    FOR_EACH (StringVectCIter, i, skins->names)
    {
        if (!VirtFs::isDirectory((branding.getStringValue(
            "systemsounds") + *i)))
        {
            std::string str = *i;
            if (findCutLast(str, ".ogg"))
                list.push_back(str);
        }
    }
 
    VirtFs::freeList(skins);
    std::sort(list.begin(), list.end());
}

References branding, VirtFs::enumerateFiles(), findCutLast(), FOR_EACH, VirtFs::freeList(), Configuration::getStringValue(), VirtFs::isDirectory(), and VirtFs::List::names.

Referenced by SoundsModel::SoundsModel().

getColor()

const Color& Theme::getColor ( const ThemeColorIdT  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 136 of file theme.h.

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

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

Referenced by Game::addWatermark(), TextParticle::draw(), Being::drawSpeech(), TouchManager::drawText(), Widget2::getThemeCharColor(), Widget2::getThemeColor(), LocalPlayer::LocalPlayer(), Being::setSpeech(), and Being::updateColors().

getIdByChar()

ThemeColorIdT Theme::getIdByChar	(	const signed char	c,
		bool &	valid
	)		const

Definition at line 1075 of file theme.cpp.

{
    const CharColors::const_iterator it = mCharColors.find(c);
    if (it != mCharColors.end())
    {
        valid = true;
        return static_cast<ThemeColorIdT>((*it).second);
    }
 
    valid = false;
    return ThemeColorId::BROWSERBOX;
}

References anonymous_namespace{libxml.cpp}::valid.

Referenced by Widget2::getThemeCharColor().

getImageFromTheme()

Image * Theme::getImageFromTheme ( const std::string &  path )

static

Definition at line 655 of file theme.cpp.

{
    return Loader::getImage(resolveThemePath(path));
}

References Loader::getImage().

Referenced by NpcDialog::createSkinControls(), Item::getImage(), TextCommand::loadImage(), PRAGMA45(), readSkin(), Desktop::setBestFittingWallpaper(), SkillData::setIcon(), Item::setId(), ActorSprite::setupSpriteDisplay(), TestLauncher::testBackend(), TestLauncher::testDraw(), TestLauncher::testFps2(), TestLauncher::testFps3(), and TestLauncher::testRescale().

getImageFromThemeXml()

Image * Theme::getImageFromThemeXml ( const std::string &  name, const std::string &  name2  )

static

Definition at line 926 of file theme.cpp.

{
    if (theme == nullptr)
        return nullptr;
 
    Skin *const skin = theme->load(name,
        name2,
        false,
        Theme::getThemePath());
    if (skin != nullptr)
    {
        const ImageRect &rect = skin->getBorder();
        if (rect.grid[0] != nullptr)
        {
            Image *const image = rect.grid[0];
            image->incRef();
            theme->unload(skin);
            return image;
        }
        theme->unload(skin);
    }
    return nullptr;
}

References Skin::getBorder(), getThemePath(), ImageRect::grid, load(), SkinParameter::name, theme, and unload().

Referenced by AvatarListBox::AvatarListBox(), Button::loadImage(), TouchManager::loadTouchItem(), ItemContainer::setCellBackgroundImage(), Window::setResizable(), and ShortcutContainer::ShortcutContainer().

getImageSetFromTheme()

ImageSet * Theme::getImageSetFromTheme ( const std::string &  path, const int  w, const int  h  )

static

Definition at line 660 of file theme.cpp.

{
    return Loader::getImageSet(resolveThemePath(path), w, h);
}

References Loader::getImageSet().

Referenced by EquipmentWindow::fillBoxes(), EquipmentWindow::fillDefault(), Button::loadImageSet(), ProgressIndicator::ProgressIndicator(), Gui::setUseCustomCursor(), and WindowMenu::WindowMenu().

getImageSetFromThemeXml()

ImageSet * Theme::getImageSetFromThemeXml ( const std::string &  name, const std::string &  name2, const int  w, const int  h  )

static

Definition at line 951 of file theme.cpp.

{
    if (theme == nullptr)
        return nullptr;
 
    Skin *const skin = theme->load(name,
        name2,
        false,
        Theme::getThemePath());
    if (skin != nullptr)
    {
        const ImageRect &rect = skin->getBorder();
        if (rect.grid[0] != nullptr)
        {
            Image *const image = rect.grid[0];
            const SDL_Rect &rect2 = image->mBounds;
            if ((rect2.w != 0U) && (rect2.h != 0U))
            {
                ImageSet *const imageSet = Loader::getSubImageSet(
                    image, w, h);
                theme->unload(skin);
                return imageSet;
            }
        }
        theme->unload(skin);
    }
    return nullptr;
}

References Skin::getBorder(), Loader::getSubImageSet(), getThemePath(), ImageRect::grid, load(), SkinParameter::name, theme, and unload().

getMinimumOpacity()

float Theme::getMinimumOpacity ( ) const

inline

Get the minimum opacity allowed to skins.

Definition at line 124 of file theme.h.

        { return mMinimumOpacity; }

References mMinimumOpacity.

Referenced by Button::updateAlpha(), CheckBox::updateAlpha(), DropDown::updateAlpha(), ListBox::updateAlpha(), ProgressBar::updateAlpha(), RadioButton::updateAlpha(), ScrollArea::updateAlpha(), SkillRectangleListBox::updateAlpha(), Slider::updateAlpha(), Tab::updateAlpha(), and TextField::updateAlpha().

getProgressColor()

Color Theme::getProgressColor ( const ProgressColorIdT  type, const float  progress  )

static

Definition at line 155 of file theme.cpp.

{
    int color[3] = {0, 0, 0};
 
    if (theme != nullptr)
    {
        const DyePalette *const dye
            = theme->mProgressColors[CAST_SIZE(type)];
 
        if (dye != nullptr)
        {
            dye->getColor(progress, color);
        }
        else
        {
            logger->log("color not found: "
                + toString(CAST_S32(type)));
        }
    }
 
    return Color(color[0], color[1], color[2], 255U);
}

References CAST_S32, CAST_SIZE, DyePalette::getColor(), Logger::log(), logger, mProgressColors, theme, and Catch::toString().

Referenced by AvatarListBox::draw(), ProgressBar::ProgressBar(), AvatarListBox::safeDraw(), ProgressBar::setProgress(), and ProgressBar::setProgressPalette().

getThemeName()

static std::string Theme::getThemeName ( )

inlinestatic

Definition at line 70 of file theme.h.

        { return mThemeName; }

References mThemeName.

Referenced by Setup_Theme::Setup_Theme().

getThemePath()

static std::string Theme::getThemePath ( )

inlinestatic

Definition at line 67 of file theme.h.

        { return mThemePath; }

References mThemePath.

Referenced by BrowserBox::BrowserBox(), CheckBox::CheckBox(), Desktop::Desktop(), DropDown::DropDown(), Client::gameInit(), getImageFromThemeXml(), getImageSetFromThemeXml(), Button::init(), Label::init(), Tab::init(), ScrollArea::init(), ListBox::ListBox(), TouchManager::loadButtons(), loadRect(), loadSkinRect(), Pincode::Pincode(), Popup::Popup(), ProgressBar::ProgressBar(), RadioButton::RadioButton(), SkillRectangleListBox::SkillRectangleListBox(), StaticBrowserBox::StaticBrowserBox(), TestLauncher::testDraw(), TextPreview::TextPreview(), and Window::Window().

load()

Skin * Theme::load	(	const std::string &	filename,
		const std::string &	filename2,
		const bool	full,
		const std::string &	defaultPath
	)

Loads a skin.

Definition at line 179 of file theme.cpp.

{
    // Check if this skin was already loaded
 
    const SkinIterator skinIterator = mSkins.find(filename);
    if (mSkins.end() != skinIterator)
    {
        if (skinIterator->second != nullptr)
            skinIterator->second->instances++;
        return skinIterator->second;
    }
 
    Skin *skin = nullptr;
    if (mScreenDensity.empty())
    {   // if no density detected
        skin = readSkin(filename, full);
        if ((skin == nullptr) && !filename2.empty() && filename2 != filename)
            skin = readSkin(filename2, full);
        if ((skin == nullptr) && filename2 != "window.xml")
            skin = readSkin("window.xml", full);
    }
    else
    {   // first use correct density images
        const std::string endStr("_" + mScreenDensity + ".xml");
        std::string name = filename;
        if (findCutLast(name, ".xml"))
            skin = readSkin(name + endStr, full);
        if (skin == nullptr)
            skin = readSkin(filename, full);
        if ((skin == nullptr) && !filename2.empty() && filename2 != filename)
        {
            name = filename2;
            if (findCutLast(name, ".xml"))
                skin = readSkin(name + endStr, full);
            if (skin == nullptr)
                skin = readSkin(filename2, full);
        }
        if ((skin == nullptr) && filename2 != "window.xml")
        {
            skin = readSkin("window" + endStr, full);
            if (skin == nullptr)
                skin = readSkin("window.xml", full);
        }
    }
 
    if (skin == nullptr)
    {
        // Try falling back on the defaultPath if this makes sense
        if (filename != defaultPath)
        {
            logger->log("Error loading skin '%s', falling back on default.",
                        filename.c_str());
 
            skin = readSkin(defaultPath, full);
        }
 
        if (skin == nullptr)
        {
            logger->log(strprintf("Error: Loading default skin '%s' failed. "
                                  "Make sure the skin file is valid.",
                                  defaultPath.c_str()));
        }
    }
 
    mSkins[filename] = skin;
    return skin;
}

References findCutLast(), Logger::log(), logger, mScreenDensity, mSkins, readSkin(), and strprintf().

Referenced by BrowserBox::BrowserBox(), CheckBox::CheckBox(), Desktop::Desktop(), DropDown::DropDown(), Client::gameInit(), getImageFromThemeXml(), getImageSetFromThemeXml(), Button::init(), Label::init(), Tab::init(), ScrollArea::init(), ListBox::ListBox(), TouchManager::loadButtons(), Pincode::Pincode(), Popup::Popup(), ProgressBar::ProgressBar(), RadioButton::RadioButton(), SkillRectangleListBox::SkillRectangleListBox(), StaticBrowserBox::StaticBrowserBox(), TestLauncher::testDraw(), TextPreview::TextPreview(), and Window::Window().

loadColors()

void Theme::loadColors ( std::string  file )

private

Definition at line 791 of file theme.cpp.

{
    if (file.empty())
        file = "colors.xml";
    else
        file = pathJoin(file, "colors.xml");
 
    XML::Document *const doc = Loader::getXml(resolveThemePath(file),
        UseVirtFs_true,
        SkipError_false);
    if (doc == nullptr)
        return;
    XmlNodeConstPtrConst root = doc->rootNode();
 
    if ((root == nullptr) || !xmlNameEqual(root, "colors"))
    {
        logger->log("Error loading colors file: %s", file.c_str());
        doc->decRef();
        return;
    }
 
    logger->log("Loading colors file: %s", file.c_str());
 
    for_each_xml_child_node(paletteNode, root)
    {
        if (xmlNameEqual(paletteNode, "progressbar"))
        {
            const int type = readProgressType(XML::getProperty(
                paletteNode, "id", ""));
            if (type < 0)
                continue;
 
            mProgressColors[type] = new DyePalette(XML::getProperty(
                paletteNode, "color", ""), 6);
        }
        else if (!xmlNameEqual(paletteNode, "palette"))
        {
            continue;
        }
 
        const int paletteId = XML::getProperty(paletteNode, "id", 1);
        if (paletteId < 0 || paletteId >= THEME_PALETTES)
            continue;
 
        for_each_xml_child_node(node, paletteNode)
        {
            if (xmlNameEqual(node, "color"))
            {
                const std::string id = XML::getProperty(node, "id", "");
                const int type = readColorType(id);
                if (type < 0)
                    continue;
 
                const std::string temp = XML::getProperty(node, "color", "");
                if (temp.empty())
                    continue;
 
                const Color color = readColor(temp);
                const GradientTypeT grad = readColorGradient(
                    XML::getProperty(node, "effect", ""));
                mColors[paletteId * CAST_SIZE(
                    ThemeColorId::THEME_COLORS_END) + type].set(
                    type, color, grad, 10);
 
                if (!findLast(id, "_OUTLINE"))
                {
                    const int type2 = readColorType(id + "_OUTLINE");
                    if (type2 < 0)
                        continue;
                    const int idx = paletteId
                        * CAST_S32(ThemeColorId::THEME_COLORS_END);
                    mColors[idx + type2] = mColors[idx + type];
                }
            }
        }
    }
    doc->decRef();
}

References CAST_S32, CAST_SIZE, Resource::decRef(), findLast(), for_each_xml_child_node, XML::getProperty(), Loader::getXml(), Logger::log(), logger, anonymous_namespace{palettedb.cpp}::mColors, pathJoin(), readColor(), readColorGradient(), readColorType(), readProgressType(), XML::Document::rootNode(), SkipError_false, THEME_PALETTES, and UseVirtFs_true.

Referenced by prepareThemePath(), and tryThemePath().

loadInfo()

ThemeInfo * Theme::loadInfo ( const std::string &  themeName )

static

Definition at line 1006 of file theme.cpp.

{
    std::string path;
    if (themeName.empty())
    {
        path = "graphics/gui/info.xml";
    }
    else
    {
        path = pathJoin(defaultThemePath,
            themeName,
            "info.xml");
    }
    logger->log("loading: " + path);
    XML::Document *const doc = Loader::getXml(path,
        UseVirtFs_true,
        SkipError_false);
    if (doc == nullptr)
        return nullptr;
    XmlNodeConstPtrConst rootNode = doc->rootNode();
 
    if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "info"))
    {
        doc->decRef();
        return nullptr;
    }
 
    ThemeInfo *const info = new ThemeInfo;
 
    const std::string fontSize2("fontSize_" + mScreenDensity);
    const std::string npcfontSize2("npcfontSize_" + mScreenDensity);
    XmlChar *tmpData = nullptr;
    for_each_xml_child_node(infoNode, rootNode)
    {
        if (xmlNameEqual(infoNode, "name"))
            readValue(name)
        else if (xmlNameEqual(infoNode, "copyright"))
            readValue(copyright)
        else if (xmlNameEqual(infoNode, "font"))
            readValue(font)
        else if (xmlNameEqual(infoNode, "boldFont"))
            readValue(boldFont)
        else if (xmlNameEqual(infoNode, "particleFont"))
            readValue(particleFont)
        else if (xmlNameEqual(infoNode, "helpFont"))
            readValue(helpFont)
        else if (xmlNameEqual(infoNode, "secureFont"))
            readValue(secureFont)
        else if (xmlNameEqual(infoNode, "npcFont"))
            readValue(npcFont)
        else if (xmlNameEqual(infoNode, "japanFont"))
            readValue(japanFont)
        else if (xmlNameEqual(infoNode, "chinaFont"))
            readValue(chinaFont)
        else if (xmlNameEqual(infoNode, "fontSize"))
            readIntValue(fontSize)
        else if (xmlNameEqual(infoNode, "npcfontSize"))
            readIntValue(npcfontSize)
        else if (xmlNameEqual(infoNode, "guialpha"))
            readFloatValue(guiAlpha)
        else if (xmlNameEqual(infoNode, fontSize2.c_str()))
            readIntValue(fontSize)
        else if (xmlNameEqual(infoNode, npcfontSize2.c_str()))
            readIntValue(npcfontSize)
    }
    doc->decRef();
    return info;
}

References boldFont, Resource::decRef(), defaultThemePath, for_each_xml_child_node, Loader::getXml(), Actions::info(), Logger::log(), logger, SkinParameter::name, pathJoin(), readFloatValue, readIntValue, readValue, XML::Document::rootNode(), SkipError_false, and UseVirtFs_true.

Referenced by Setup_Theme::updateInfo().

loadRect()

void Theme::loadRect	(	ImageRect &	image,
		const std::string &	name,
		const std::string &	name2,
		const int	start,
		const int	end
	)

Definition at line 883 of file theme.cpp.

{
    Skin *const skin = load(name,
        name2,
        false,
        Theme::getThemePath());
    if (skin != nullptr)
    {
        loadGrid()
        unload(skin);
    }
}

References getThemePath(), AvatarDB::load(), loadGrid, SkinParameter::name, and Net::unload().

Referenced by DropDown::DropDown(), Slider::init(), ScrollArea::init(), EquipmentWindow::postInit(), ProgressBar::ProgressBar(), and Text::Text().

loadSkinRect()

Skin * Theme::loadSkinRect	(	ImageRect &	image,
		const std::string &	name,
		const std::string &	name2,
		const int	start,
		const int	end
	)

Definition at line 900 of file theme.cpp.

{
    Skin *const skin = load(name,
        name2,
        true,
        Theme::getThemePath());
    if (skin != nullptr)
        loadGrid()
    return skin;
}

References getThemePath(), AvatarDB::load(), loadGrid, and SkinParameter::name.

Referenced by PlayerBox::init(), TouchManager::loadTouchItem(), and TextField::TextField().

optionChanged()

void Theme::optionChanged ( const std::string &  name )

virtual

Called when an option changed. The config listener will have to be registered to the option name first.

Implements ConfigListener.

Definition at line 291 of file theme.cpp.

{
    updateAlpha();
}

References updateAlpha().

prepareThemePath()

void Theme::prepareThemePath ( )

static

Definition at line 604 of file theme.cpp.

{
    initDefaultThemePath();
 
    mThemePath.clear();
    mThemeName.clear();
 
    // Try theme from settings
    if (tryThemePath(config.getStringValue("theme")))
        return;
 
    // Try theme from branding
    if (tryThemePath(branding.getStringValue("theme")))
        return;
 
    if (mThemePath.empty())
        mThemePath = "graphics/gui";
 
    theme->loadColors(mThemePath);
 
    logger->log("Selected Theme: " + mThemePath);
}

References branding, config, Configuration::getStringValue(), initDefaultThemePath(), loadColors(), Logger::log(), logger, and theme.

readSkin()

Skin * Theme::readSkin ( const std::string &  filename0, const bool  full  )

private

Definition at line 394 of file theme.cpp.

{
    if (filename.empty())
        return nullptr;
 
    const std::string path = resolveThemePath(filename);
    if (!VirtFs::exists(path))
        return nullptr;
    XML::Document *const doc = Loader::getXml(path,
        UseVirtFs_true,
        SkipError_true);
    if (doc == nullptr)
        return nullptr;
    XmlNodeConstPtr rootNode = doc->rootNode();
    if ((rootNode == nullptr) || !xmlNameEqual(rootNode, "skinset"))
    {
        doc->decRef();
        return nullptr;
    }
 
    const std::string skinSetImage = XML::getProperty(rootNode, "image", "");
 
    if (skinSetImage.empty())
    {
        logger->log1("Theme::readSkin(): Skinset does not define an image!");
        doc->decRef();
        return nullptr;
    }
 
    Image *const dBorders = Theme::getImageFromTheme(skinSetImage);
    ImageRect *const border = new ImageRect;
    ImageRect *const images = new ImageRect;
    int padding = 3;
    int titlePadding = 4;
    int titlebarHeight = 0;
    int titlebarHeightRelative = 0;
    int closePadding = 3;
    int stickySpacing = 3;
    int stickyPadding = 3;
    int resizePadding = 2;
    StringIntMap *const mOptions = new StringIntMap;
 
    // iterate <widget>'s
    for_each_xml_child_node(widgetNode, rootNode)
    {
        if (!xmlNameEqual(widgetNode, "widget"))
            continue;
 
        const std::string widgetType =
                XML::getProperty(widgetNode, "type", "unknown");
        if (widgetType == "Window")
        {
            SkinHelper helper;
            const int globalXPos = XML::getProperty(widgetNode, "xpos", 0);
            const int globalYPos = XML::getProperty(widgetNode, "ypos", 0);
            for_each_xml_child_node(partNode, widgetNode)
            {
                if (xmlNameEqual(partNode, "part"))
                {
                    helper.partType = XML::getProperty(
                        partNode, "type", "unknown");
                    helper.xPos = XML::getProperty(
                        partNode, "xpos", 0) + globalXPos;
                    helper.yPos = XML::getProperty(
                        partNode, "ypos", 0) + globalYPos;
                    helper.width = XML::getProperty(partNode, "width", 0);
                    helper.height = XML::getProperty(partNode, "height", 0);
                    if ((helper.width == 0) || (helper.height == 0))
                        continue;
                    helper.image = dBorders;
 
                    helper.rect = border;
                    if (!helper.loadList(skinParam,
                        sizeof(skinParam) / sizeof(SkinParameter)))
                    {
                        helper.rect = images;
                        helper.loadList(imageParam,
                            sizeof(imageParam) / sizeof(SkinParameter));
                    }
                }
                else if (full && xmlNameEqual(partNode, "option"))
                {
                    const std::string name = XML::getProperty(
                        partNode, "name", "");
                    if (name == "padding")
                    {
                        padding = XML::getProperty(partNode, "value", 3);
                    }
                    else if (name == "titlePadding")
                    {
                        titlePadding = XML::getProperty(partNode, "value", 4);
                    }
                    else if (name == "closePadding")
                    {
                        closePadding = XML::getProperty(partNode, "value", 3);
                    }
                    else if (name == "stickySpacing")
                    {
                        stickySpacing = XML::getProperty(partNode, "value", 3);
                    }
                    else if (name == "stickyPadding")
                    {
                        stickyPadding = XML::getProperty(partNode, "value", 3);
                    }
                    else if (name == "titlebarHeight")
                    {
                        titlebarHeight = XML::getProperty(
                            partNode, "value", 0);
                    }
                    else if (name == "titlebarHeightRelative")
                    {
                        titlebarHeightRelative = XML::getProperty(
                            partNode, "value", 0);
                    }
                    else if (name == "resizePadding")
                    {
                        resizePadding = XML::getProperty(
                            partNode, "value", 2);
                    }
                    else
                    {
                        (*mOptions)[name] = XML::getProperty(
                            partNode, "value", 0);
                    }
                }
            }
        }
        else
        {
            logger->log("Theme::readSkin(): Unknown widget type '%s'",
                        widgetType.c_str());
        }
    }
 
    if (dBorders != nullptr)
        dBorders->decRef();
 
    (*mOptions)["closePadding"] = closePadding;
    (*mOptions)["stickyPadding"] = stickyPadding;
    (*mOptions)["stickySpacing"] = stickySpacing;
    (*mOptions)["titlebarHeight"] = titlebarHeight;
    (*mOptions)["titlebarHeightRelative"] = titlebarHeightRelative;
    (*mOptions)["resizePadding"] = resizePadding;
 
    Skin *const skin = new Skin(border, images, filename, "", padding,
        titlePadding, mOptions);
    delete images;
    skin->updateAlpha(mMinimumOpacity);
    doc->decRef();
    return skin;
}

References Resource::decRef(), VirtFs::exists(), for_each_xml_child_node, getImageFromTheme(), XML::getProperty(), Loader::getXml(), SkinHelper::height, SkinHelper::image, imageParam, SkinHelper::loadList(), Logger::log(), Logger::log1(), logger, anonymous_namespace{itemoptiondb.cpp}::mOptions, SkinParameter::name, SkinHelper::partType, SkinHelper::rect, XML::Document::rootNode(), skinParam, SkipError_true, Skin::updateAlpha(), UseVirtFs_true, SkinHelper::width, SkinHelper::xPos, and SkinHelper::yPos.

Referenced by load().

resolveThemePath()

std::string Theme::resolveThemePath ( const std::string &  path )

static

Returns the patch to the given gui resource relative to the theme or, if it isn't in the theme, relative to 'graphics/gui'.

Definition at line 627 of file theme.cpp.

{
    // Need to strip off any dye info for the existence tests
    const int pos = CAST_S32(path.find('|'));
    std::string file;
    if (pos > 0)
        file = path.substr(0, pos);
    else
        file = path;
 
    // File with path
    if (file.find('/') != std::string::npos)
    {
        // Might be a valid path already
        if (VirtFs::exists(file))
            return path;
    }
 
    // Try the theme
    file = pathJoin(getThemePath(), file);
 
    if (VirtFs::exists(file))
        return pathJoin(getThemePath(), path);
 
    // Backup
    return pathJoin(branding.getStringValue("guiPath"), path);
}

References branding, CAST_S32, VirtFs::exists(), Configuration::getStringValue(), and pathJoin().

Referenced by ActorSprite::initTargetCursor().

selectSkin()

void Theme::selectSkin ( )

static

Definition at line 598 of file theme.cpp.

{
    prepareThemePath();
    mScreenDensity = graphicsManager.getDensityString();
}

References GraphicsManager::getDensityString(), and graphicsManager.

Referenced by Client::gameInit().

setMinimumOpacity()

void Theme::setMinimumOpacity

(

const float

minimumOpacity

)

Set the minimum opacity allowed to skins. Set a negative value to free the minimum allowed.

Definition at line 272 of file theme.cpp.

{
    if (minimumOpacity > 1.0F)
        return;
 
    mMinimumOpacity = minimumOpacity;
    updateAlpha();
}

References mMinimumOpacity, and updateAlpha().

tryThemePath()

bool Theme::tryThemePath ( const std::string &  themePath )

staticprivate

Definition at line 546 of file theme.cpp.

{
    if (!themeName.empty())
    {
        const std::string path = defaultThemePath + themeName;
        if (VirtFs::exists(path))
        {
            mThemePath = path;
            mThemeName = themeName;
            if (theme != nullptr)
                theme->loadColors("");
            return true;
        }
    }
 
    return false;
}

References defaultThemePath, VirtFs::exists(), loadColors(), and theme.

unload()

void Theme::unload

(

Skin *const

skin

)

Definition at line 250 of file theme.cpp.

{
    if (skin == nullptr)
        return;
    skin->instances --;
    if (skin->instances == 0)
    {
        SkinIterator it = mSkins.begin();
        const SkinIterator it_end = mSkins.end();
        while (it != it_end)
        {
            if (it->second == skin)
            {
                mSkins.erase(it);
                break;
            }
            ++ it;
        }
        delete skin;
    }
}

References Skin::instances, and mSkins.

Referenced by DropDown::DropDown(), getImageFromThemeXml(), getImageSetFromThemeXml(), ScrollArea::init(), TouchManager::loadButtons(), TouchManager::loadTouchItem(), BrowserBox::~BrowserBox(), Button::~Button(), CheckBox::~CheckBox(), Desktop::~Desktop(), DropDown::~DropDown(), ItemContainer::~ItemContainer(), Label::~Label(), ListBox::~ListBox(), Pincode::~Pincode(), Popup::~Popup(), ProgressBar::~ProgressBar(), RadioButton::~RadioButton(), StaticBrowserBox::~StaticBrowserBox(), Tab::~Tab(), TextField::~TextField(), TextPreview::~TextPreview(), Window::~Window(), and WindowMenu::~WindowMenu().

unloadRect()

void Theme::unloadRect ( const ImageRect &  rect, const int  start, const int  end  )

static

Definition at line 915 of file theme.cpp.

{
    for (int f = start; f <= end; f ++)
    {
        if (rect.grid[f] != nullptr)
            rect.grid[f]->decRef();
    }
}

References ImageRect::grid, and anonymous_namespace{stringutils.cpp}::start.

Referenced by TouchManager::unload(), DropDown::~DropDown(), PlayerBox::~PlayerBox(), ProgressBar::~ProgressBar(), ScrollArea::~ScrollArea(), Slider::~Slider(), and TextField::~TextField().

updateAlpha()

void Theme::updateAlpha

(

)

Updates the alpha values of all of the skins.

Definition at line 281 of file theme.cpp.

{
    FOR_EACH (SkinIterator, iter, mSkins)
    {
        Skin *const skin = iter->second;
        if (skin != nullptr)
            skin->updateAlpha(mMinimumOpacity);
    }
}

References FOR_EACH, mMinimumOpacity, mSkins, and Skin::updateAlpha().

Referenced by optionChanged(), and setMinimumOpacity().

Field Documentation

mMinimumOpacity

float Theme::mMinimumOpacity

private

Tells if the current skins opacity should not get less than the given value

Definition at line 206 of file theme.h.

Referenced by getMinimumOpacity(), setMinimumOpacity(), and updateAlpha().

mProgressColors

ProgressColors Theme::mProgressColors

private

Definition at line 209 of file theme.h.

Referenced by getProgressColor(), and ~Theme().

mScreenDensity

std::string Theme::mScreenDensity

staticprivate

Definition at line 196 of file theme.h.

Referenced by load().

mSkins

Skins Theme::mSkins

private

Definition at line 192 of file theme.h.

Referenced by load(), unload(), updateAlpha(), and ~Theme().

mThemeName

std::string Theme::mThemeName

staticprivate

Definition at line 195 of file theme.h.

Referenced by getThemeName().

mThemePath

std::string Theme::mThemePath

staticprivate

Definition at line 194 of file theme.h.

Referenced by getThemePath().

---

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

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