guiSkin.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#ifndef __GUI_SKIN_H_INCLUDED__
#define __GUI_SKIN_H_INCLUDED__
 
#include "IGUISkin.h"
#include "irrString.h"
#include <string>
#include "ITexture.h"
 
namespace irr
{
namespace video
{
        class IVideoDriver;
}
namespace gui
{
        class GUISkin : public IGUISkin
        {
        public:
 
                GUISkin(EGUI_SKIN_TYPE type, video::IVideoDriver* driver);
 
                virtual ~GUISkin();
 
                virtual float getScale() const { return Scale; }
 
                virtual void setScale(float scale) { Scale = scale; }
 
                virtual video::SColor getColor(EGUI_DEFAULT_COLOR color) const;
 
                virtual void setColor(EGUI_DEFAULT_COLOR which, video::SColor newColor);
 
                virtual s32 getSize(EGUI_DEFAULT_SIZE size) const;
 
                virtual void setSize(EGUI_DEFAULT_SIZE which, s32 size);
 
                virtual IGUIFont* getFont(EGUI_DEFAULT_FONT which=EGDF_DEFAULT) const;
 
                virtual void setFont(IGUIFont* font, EGUI_DEFAULT_FONT which=EGDF_DEFAULT);
 
                virtual void setSpriteBank(IGUISpriteBank* bank);
 
                virtual IGUISpriteBank* getSpriteBank() const;
 
 
                virtual u32 getIcon(EGUI_DEFAULT_ICON icon) const;
 
 
                virtual void setIcon(EGUI_DEFAULT_ICON icon, u32 index);
 
 
                virtual const wchar_t* getDefaultText(EGUI_DEFAULT_TEXT text) const;
 
 
                virtual void setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t* newText);
 
 
                virtual void draw3DButtonPaneStandard(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0)
                {
                        drawColored3DButtonPaneStandard(element, rect,clip);
                }
 
                virtual void drawColored3DButtonPaneStandard(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual void draw3DButtonPanePressed(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0)
                {
                        drawColored3DButtonPanePressed(element, rect, clip);
                }
 
                virtual void drawColored3DButtonPanePressed(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual void draw3DSunkenPane(IGUIElement* element,
                                video::SColor bgcolor, bool flat,
                                bool fillBackGround,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0)
                {
                        drawColored3DSunkenPane(element, bgcolor, flat, fillBackGround, rect, clip);
                }
 
                virtual void drawColored3DSunkenPane(IGUIElement* element,
                                video::SColor bgcolor, bool flat,
                                bool fillBackGround,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual core::rect<s32> draw3DWindowBackground(IGUIElement* element,
                                bool drawTitleBar, video::SColor titleBarColor,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip,
                                core::rect<s32>* checkClientArea)
                {
                        return drawColored3DWindowBackground(element, drawTitleBar, titleBarColor,
                                rect, clip, checkClientArea);
                }
 
                virtual core::rect<s32> drawColored3DWindowBackground(IGUIElement* element,
                                bool drawTitleBar, video::SColor titleBarColor,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip,
                                core::rect<s32>* checkClientArea,
                                const video::SColor* colors=0);
 
 
                virtual void draw3DMenuPane(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0)
                {
                        drawColored3DMenuPane(element, rect, clip);
                }
 
                virtual void drawColored3DMenuPane(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual void draw3DToolBar(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0)
                {
                        drawColored3DToolBar(element, rect, clip);
                }
 
                virtual void drawColored3DToolBar(IGUIElement* element,
                                const core::rect<s32>& rect,
                                const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual void draw3DTabButton(IGUIElement* element, bool active,
                        const core::rect<s32>& rect, const core::rect<s32>* clip=0, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT)
                {
                        drawColored3DTabButton(element, active, rect, clip, alignment);
                }
 
                virtual void drawColored3DTabButton(IGUIElement* element, bool active,
                        const core::rect<s32>& rect, const core::rect<s32>* clip=0, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT,
                        const video::SColor* colors=0);
 
 
                virtual void draw3DTabBody(IGUIElement* element, bool border, bool background,
                        const core::rect<s32>& rect, const core::rect<s32>* clip=0, s32 tabHeight=-1, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT)
                {
                        drawColored3DTabBody(element, border, background, rect, clip, tabHeight, alignment);
                }
 
                virtual void drawColored3DTabBody(IGUIElement* element, bool border, bool background,
                        const core::rect<s32>& rect, const core::rect<s32>* clip=0, s32 tabHeight=-1, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT,
                        const video::SColor* colors=0);
 
 
                virtual void drawIcon(IGUIElement* element, EGUI_DEFAULT_ICON icon,
                                const core::position2di position,
                                u32 starttime=0, u32 currenttime=0,
                                bool loop=false, const core::rect<s32>* clip=0)
                {
                        drawColoredIcon(element, icon, position, starttime, currenttime, loop, clip);
                }
 
                virtual void drawColoredIcon(IGUIElement* element, EGUI_DEFAULT_ICON icon,
                                const core::position2di position,
                                u32 starttime=0, u32 currenttime=0,
                                bool loop=false, const core::rect<s32>* clip=0,
                                const video::SColor* colors=0);
 
 
                virtual void draw2DRectangle(IGUIElement* element, const video::SColor &color,
                                const core::rect<s32>& pos, const core::rect<s32>* clip = 0);
 
 
                virtual EGUI_SKIN_TYPE getType() const;
 
                virtual void getColors(video::SColor* colors); // ::PATCH:
 
        private:
 
                float Scale = 1.0f;
                video::SColor Colors[EGDC_COUNT];
                s32 Sizes[EGDS_COUNT];
                u32 Icons[EGDI_COUNT];
                IGUIFont* Fonts[EGDF_COUNT];
                IGUISpriteBank* SpriteBank;
                core::stringw Texts[EGDT_COUNT];
                video::IVideoDriver* Driver;
                bool UseGradient;
 
                EGUI_SKIN_TYPE Type;
        };
 
        #define set3DSkinColors(skin, button_color) \
                { \
                        skin->setColor(EGDC_3D_FACE, button_color); \
                        skin->setColor(EGDC_3D_DARK_SHADOW, button_color, 0.25f); \
                        skin->setColor(EGDC_3D_SHADOW, button_color, 0.5f); \
                        skin->setColor(EGDC_3D_LIGHT, button_color); \
                        skin->setColor(EGDC_3D_HIGH_LIGHT, button_color, 1.5f); \
                }
 
        #define getElementSkinColor(color) \
                { \
                        if (!Colors) \
                        { \
                                IGUISkin* skin = Environment->getSkin(); \
                                if (skin) \
                                        return skin->getColor(color); \
                        } \
                        return Colors[color]; \
                }
 
        #define setElementSkinColor(which, newColor, shading) \
                { \
                        if (!Colors) \
                        { \
                                Colors = new video::SColor[EGDC_COUNT]; \
                                GUISkin* skin = (GUISkin *)Environment->getSkin(); \
                                if (skin) \
                                        skin->getColors(Colors); \
                        } \
                        Colors[which] = newColor; \
                        setShading(Colors[which],shading); \
                }
} // end namespace gui
inline void setShading(video::SColor &color,f32 s) // :PATCH:
{
        if (s < 1.0f)
        {
                color.setRed(color.getRed() * s);
                color.setGreen(color.getGreen() * s);
                color.setBlue(color.getBlue() * s);
        }
        else if (s > 1.0f)
        {
                s -= 1.0f;
 
                color.setRed(color.getRed() + (255 - color.getRed()) * s);
                color.setGreen(color.getGreen() + (255 - color.getGreen()) * s);
                color.setBlue(color.getBlue() + (255 - color.getBlue()) * s);
        }
}
} // end namespace irr
 
#endif