Subversion Repositories tpanel

/*

 * Copyright (C) 2021, 2022 by Andreas Theofilu <andreas@theosys.at>

 *

 * 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 3 of the License, or

 * (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 */

#ifndef __TSYSTEMDRAW_H__

#define __TSYSTEMDRAW_H__

#include <string>

#include <vector>

#include <functional>

#include <expat.h>

#include "tvalidatefile.h"

#include "tdirectory.h"

typedef enum SLIDER_GRTYPE_t

{

    SGR_TOP,

    SGR_BOTTOM,

    SGR_LEFT,

    SGR_RIGHT,

    SGR_HORIZONTAL,

    SGR_VERTICAL

}SLIDER_GRTYPE_t;

typedef struct FAMILY_t

{

    std::string name;

    std::vector<std::string> member;

}FAMILY_t;

typedef struct BORDER_STYLE_t

{

    std::string name;

    std::string off;

    std::string on;

    std::string drag;

    std::string drop;

    std::vector<int> g3Equiv;

}BORDER_STYLE_t;

typedef struct BORDER_DATA_t

{

    std::string name;

    std::string baseFile;

    int multiColor;

    int fillTop;

    int fillLeft;

    int fillBottom;

    int fillRight;

    int textTop;

    int textLeft;

    int textBottom;

    int textRight;

    int idealWidth;

    int idealHeight;

    int minHeight;

    int minWidth;

    int incHeight;

    int incWidth;

    void init()

    {

        multiColor = 0;

        fillTop = 0;

        fillLeft = 0;

        fillBottom = 0;

        fillRight = 0;

        textTop = 0;

        textLeft = 0;

        textBottom = 0;

        textRight = 0,

        idealWidth = 0;

        idealHeight = 0;

        minHeight = 0;

        minWidth = 0;

        incHeight = 0;

        incWidth = 0;

    }

}BORDER_DATA_t;

typedef struct CURSOR_STYLE_t

{

    std::string name;

    std::string baseFile;

    int multiColor;

    std::vector<int> g3Equiv;

    void init()

    {

        multiColor = 0;

    }

}CURSOR_STYLE_t;

typedef struct SLIDER_STYLE_t

{

    std::string name;

    std::string baseFile;

    int multiColor;

    int incRepeat;

    int minSize;

    int fixedSize;

    std::vector<int> g3Equiv;

    void init()

    {

        multiColor = 0;

        incRepeat = 0;

        minSize = 0;

        fixedSize = 0;

    }

}SLIDER_STYLE_t;

typedef struct EFFECT_STYLE_t

{

    std::string name;

    int number;

    int startx;

    int starty;

    int height;

    int width;

    int cutout;

    std::string pixelMap;

    void init()

    {

        number = 0;

        startx = 0;

        starty = 0;

        height = 0;

        width = 0;

        cutout = 0;

    }

}EFFECT_STYLE_t;

typedef struct POPUP_EFFECT_t

{

    std::string name;

    int number;

    int valueUsed;

    void init()

    {

        number = 0;

        valueUsed = 0;

    }

}POPUP_EFFECT_t;

typedef struct DRAW_t

{

    std::vector<FAMILY_t> borders;

    std::vector<BORDER_STYLE_t> borderStyles;

    std::vector<BORDER_DATA_t> borderData;

    std::vector<FAMILY_t> cursors;

    std::vector<CURSOR_STYLE_t> cursorStyles;

    std::vector<FAMILY_t> sliders;

    std::vector<SLIDER_STYLE_t> sliderStyles;

    std::vector<FAMILY_t> effects;

    std::vector<EFFECT_STYLE_t> effectStyles;

    std::vector<POPUP_EFFECT_t> popupEffects;

}DRAW_t;

typedef struct BORDER_t

{

    std::string bl;         // bottom left corner

    std::string b;          // bottom

    std::string br;         // bottom right corner

    std::string r;          // right

    std::string tr;         // top right corner

    std::string t;          // top

    std::string tl;         // top left corner

    std::string l;          // left

    std::string bl_alpha;   // bottom left corner

    std::string b_alpha;    // bottom

    std::string br_alpha;   // bottom right corner

    std::string r_alpha;    // right

    std::string tr_alpha;   // top right corner

    std::string t_alpha;    // top

    std::string tl_alpha;   // top left corner

    std::string l_alpha;    // left

    BORDER_DATA_t border;   // Border data

    BORDER_STYLE_t bdStyle; // The border style data

}BORDER_t;

typedef struct SLIDER_t

{

    SLIDER_GRTYPE_t type;   //<! The type of the file the path is pointing to

    std::string path;       //<! The path and file name of the graphics mask file.

    std::string pathAlpha;  //<! The path and file name of the graphics file containing the alpha part of the image.

}SLIDER_t;

typedef struct CURSOR_t

{

    std::string imageBase;  // The base image file.

    std::string imageAlpha; // The alpha image file.

}CURSOR_t;

/**

 * @brief Class to manage system resources like borders, sliders, ...

 *

 * \c TSystemDraw reads the system configuration file draw.xma. This is

 * usualy located in the system directory __system/graphics.

 */

class TSystemDraw : public TValidateFile

{

    public:

        typedef enum LINE_TYPE_t

        {

            LT_OFF,

            LT_ON,

            LT_DRAG,

            LT_DROP

        }LINE_TYPE_t;

        TSystemDraw(const std::string& path);

        ~TSystemDraw();

        bool loadConfig();

        bool getBorder(const std::string& family, LINE_TYPE_t lt, BORDER_t *border, const std::string& family2="", bool info=false);

        bool getBorderInfo(const std::string& family, LINE_TYPE_t lt, BORDER_t *border, const std::string& family2="");

        bool existBorder(const std::string& family);

        int getBorderWidth(const std::string& family, LINE_TYPE_t lt = LT_OFF);

        int getBorderHeight(const std::string& family, LINE_TYPE_t lt = LT_OFF);

        bool existSlider(const std::string& slider);

        bool getSlider(const std::string& slider, SLIDER_STYLE_t *style);

        std::vector<SLIDER_t> getSliderFiles(const std::string& slider);

        bool getCursor(const std::string& cursor, CURSOR_STYLE_t *style);

        bool existCursor(const std::string& cursor);

        CURSOR_t getCursorFiles(const CURSOR_STYLE_t& style);

    protected:

        static void startElement(void *, const XML_Char *name, const XML_Char **);

        static void XMLCALL endElement(void *userData, const XML_Char *name);

        static void XMLCALL CharacterDataHandler(void *userData, const XML_Char *s, int len);

    private:

        typedef enum XELEMENTS_t

        {

            X_NONE,

            X_BORDER,

            X_BORDER_DATA,

            X_BORDER_FAMILY,

            X_BORDER_STYLE,

            X_CURSOR_DATA,

            X_CURSOR_FAMILY,

            X_CURSOR_STYLE,

            X_SLIDER_DATA,

            X_SLIDER_FAMILY,

            X_SLIDER_STYLE,

            X_EFFECT_DATA,

            X_EFFECT_FAMILY,

            X_EFFECT_STYLE,

            X_POPUP_EFFECT_DATA,

            X_POPUP_EFFECT

        }XELEMENTS_t;

        std::string getDirEntry(dir::TDirectory *dir, const std::string& part, bool alpha = true);

        bool evaluateName(const std::vector<std::string>& parts, const std::string& name);

        std::string mPath;          // The path to the system directory tree

        bool mValid{false};         // TRUE = the path mPath is a valid directory

        bool mHaveBorders{false};   // TRUE = system directory borders exist

        bool mHaveCursors{false};   // TRUE = system directory cursors exist

        bool mHaveFonts{false};     // TRUE = system directory fonts exist

        bool mHaveImages{false};    // TRUE = system directory images exist

        bool mHaveSliders{false};   // TRUE = system directory sliders exist

        DRAW_t mDraw;

        static XELEMENTS_t mActData;

        static XELEMENTS_t mActFamily;

        static std::string mActElement;

};

#endif