usbloadergx/source/libwiigui/gui.h

/*!\mainpage libwiigui Documentation
 *
 * \section Introduction
 * libwiigui is a GUI library for the Wii, created to help structure the
 * design of a complicated GUI interface, and to enable an author to create
 * a sophisticated, feature-rich GUI. It was originally conceived and written
 * after I started to design a GUI for Snes9x GX, and found libwiisprite and
 * GRRLIB inadequate for the purpose. It uses GX for drawing, and makes use
 * of PNGU for displaying images and FreeTypeGX for text. It was designed to
 * be flexible and is easy to modify - don't be afraid to change the way it
 * works or expand it to suit your GUI's purposes! If you do, and you think
 * your changes might benefit others, please share them so they might be
 * added to the project!
 *
 * \section Quickstart
 * Start from the supplied template example. For more advanced uses, see the
 * source code for Snes9x GX, FCE Ultra GX, and Visual Boy Advance GX.

 * \section Contact
 * If you have any suggestions for the library or documentation, or want to
 * contribute, please visit the libwiigui website:

 * http://code.google.com/p/libwiigui/
 * \section Credits
 * This library was wholly designed and written by Tantric. Thanks to the
 * authors of PNGU and FreeTypeGX, of which this library makes use. Thanks
 * also to the authors of GRRLIB and libwiisprite for laying the foundations.
 *
*/

#ifndef LIBWIIGUI_H
#define LIBWIIGUI_H

#include <gccore.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <vector>
#include <math.h>
#include <asndlib.h>
#include <wiiuse/wpad.h>
#include "pngu/pngu.h"
#include "FreeTypeGX.h"
#include "video.h"
#include "filelist.h"
#include "input.h"

extern FreeTypeGX *fontSystem;

#define SCROLL_INITIAL_DELAY    20
#define SCROLL_LOOP_DELAY       3
#define PAGESIZE                9
#define FILEBROWSERSIZE         8
#define MAX_OPTIONS             170

typedef void ( *UpdateCallback )( void * e );

enum
{
    ALIGN_LEFT,
    ALIGN_RIGHT,
    ALIGN_CENTRE,
    ALIGN_TOP,
    ALIGN_BOTTOM,
    ALIGN_MIDDLE
};
#define ALIGN_CENTER ALIGN_CENTRE
enum
{
    STATE_DEFAULT,
    STATE_SELECTED,
    STATE_CLICKED,
    STATE_HELD,
    STATE_DISABLED
};

enum
{
    IMAGE_TEXTURE,
    IMAGE_COLOR,
    IMAGE_DATA,
    IMAGE_COPY
};

enum
{
    TRIGGER_SIMPLE,
    TRIGGER_HELD,
    TRIGGER_BUTTON_ONLY,
    TRIGGER_BUTTON_ONLY_IN_FOCUS
};

enum
{
    WRAP,
    DOTTED,
    SCROLL_HORIZONTAL,
    SCROLL_NONE
};

typedef struct _paddata
{
    u16 btns_d;
    u16 btns_u;
    u16 btns_h;
    s8 stickX;
    s8 stickY;
    s8 substickX;
    s8 substickY;
    u8 triggerL;
    u8 triggerR;
} PADData;

#define EFFECT_SLIDE_TOP            1
#define EFFECT_SLIDE_BOTTOM         2
#define EFFECT_SLIDE_RIGHT          4
#define EFFECT_SLIDE_LEFT           8
#define EFFECT_SLIDE_IN             16
#define EFFECT_SLIDE_OUT            32
#define EFFECT_FADE                 64
#define EFFECT_SCALE                128
#define EFFECT_COLOR_TRANSITION     256
#define EFFECT_PULSE                512
#define EFFECT_ROCK_VERTICLE        1024
#define EFFECT_GOROUND              2048

#define MAX_SND_VOICES          16

class GuiSoundDecoder;
class GuiSound
{
    public:
        //!Constructor
        //!\param s Pointer to the sound data
        //!\param l Length of sound data
        //!\param v Sound volume (0-100)
        //!\param r RAW PCM Sound, when no decoder is found then try to play as raw-pcm
        //!\param a true--> Pointer to the sound data is allocated with new u8[...]
        //!\                GuiSound will be destroy the buffer if it no more needed
        //!\        false-> sound data buffer has to live just as long as GuiSound
        GuiSound( const u8 *s, int l, int v = 100, bool r = true, bool a = false );
        //!Constructor
        //!\param p Path to the sound data
        //!\param v Sound volume (0-100)
        GuiSound( const char *p, int v = 100 );
        //!Load - stop playing and load the new sound data
        //!       if load not failed replace the current with new sound data
        //!       otherwise the current date will not changed
        //!\params same as by Constructors
        //!\return true ok / false = failed
        bool Load( const u8 *s, int l, bool r = false, bool a = false );
        bool Load( const char *p );
        //!Destructor
        ~GuiSound();

        //!Start sound playback
        void Play();
        //!Stop sound playback
        void Stop();
        //!Pause sound playback
        void Pause();
        //!Resume sound playback
        void Resume();
        //!Checks if the sound is currently playing
        //!\return true if sound is playing, false otherwise
        bool IsPlaying();
        //!Set sound volume
        //!\param v Sound volume (0-100)
        void SetVolume( int v );
        //!Set the sound to loop playback (only applies to OGG)
        //!\param l Loop (true to loop)
        void SetLoop( bool l );
        //!Get the playing time in ms for that moment (only applies to OGG)
    protected:
        s32      voice;             // used asnd-voice
        u8      *play_buffer[3];    // trpple-playbuffer
        int      buffer_nr;         // current playbuffer
        int      buffer_pos;        // current idx to write in buffer
        bool     buffer_ready;      // buffer is filled and ready
        bool     buffer_eof;        // no mor datas - will stop playing
        bool     loop;              // play looped
        s32      volume;            // volume
        GuiSoundDecoder *decoder;

        void DecoderCallback();
        void PlayerCallback();
        friend void *GuiSoundDecoderThread( void *args );
        friend void GuiSoundPlayerCallback( s32 Voice );
};

//!Menu input trigger management. Determine if action is neccessary based on input data by comparing controller input data to a specific trigger element.
class GuiTrigger
{
    public:
        //!Constructor
        GuiTrigger();
        //!Destructor
        ~GuiTrigger();
        //!Sets a simple trigger. Requires: element is selected, and trigger button is pressed
        //!\param ch Controller channel number
        //!\param wiibtns Wii controller trigger button(s) - classic controller buttons are considered separately
        //!\param gcbtns GameCube controller trigger button(s)
        void SetSimpleTrigger( s32 ch, u32 wiibtns, u16 gcbtns );
        //!Sets a held trigger. Requires: element is selected, and trigger button is pressed
        //!\param ch Controller channel number
        //!\param wiibtns Wii controller trigger button(s) - classic controller buttons are considered separately
        //!\param gcbtns GameCube controller trigger button(s)
        void SetHeldTrigger( s32 ch, u32 wiibtns, u16 gcbtns );
        //!Sets a button-only trigger. Requires: Trigger button is pressed
        //!\param ch Controller channel number
        //!\param wiibtns Wii controller trigger button(s) - classic controller buttons are considered separately
        //!\param gcbtns GameCube controller trigger button(s)
        void SetButtonOnlyTrigger( s32 ch, u32 wiibtns, u16 gcbtns );
        //!Sets a button-only trigger. Requires: trigger button is pressed and parent window of element is in focus
        //!\param ch Controller channel number
        //!\param wiibtns Wii controller trigger button(s) - classic controller buttons are considered separately
        //!\param gcbtns GameCube controller trigger button(s)
        void SetButtonOnlyInFocusTrigger( s32 ch, u32 wiibtns, u16 gcbtns );
        //!Get X/Y value from Wii Joystick (classic, nunchuk) input
        //!\param right Controller stick (left = 0, right = 1)
        //!\param axis Controller stick axis (x-axis = 0, y-axis = 1)
        //!\return Stick value
        s8 WPAD_Stick( u8 right, int axis );
        //!Move menu selection left (via pad/joystick). Allows scroll delay and button overriding
        //!\return true if selection should be moved left, false otherwise
        bool Left();
        //!Move menu selection right (via pad/joystick). Allows scroll delay and button overriding
        //!\return true if selection should be moved right, false otherwise
        bool Right();
        //!Move menu selection up (via pad/joystick). Allows scroll delay and button overriding
        //!\return true if selection should be moved up, false otherwise
        bool Up();
        //!Move menu selection down (via pad/joystick). Allows scroll delay and button overriding
        //!\return true if selection should be moved down, false otherwise
        bool Down();

        u8 type; //!< trigger type (TRIGGER_SIMPLE, TRIGGER_HELD, TRIGGER_BUTTON_ONLY, TRIGGER_BUTTON_ONLY_IN_FOCUS)
        s32 chan; //!< Trigger controller channel (0-3, -1 for all)
        WPADData wpad; //!< Wii controller trigger data
        PADData pad; //!< GameCube controller trigger data
};

extern GuiTrigger userInput[4];

//!Primary GUI class. Most other classes inherit from this class.
class GuiElement
{
    public:
        //!Constructor
        GuiElement();
        //!Destructor
        ~GuiElement();
        //!Set the element's parent
        //!\param e Pointer to parent element
        void SetParent( GuiElement * e );
        //!Gets the element's parent
        //!\return Pointer to parent element
        GuiElement * GetParent();
        //!Gets the current leftmost coordinate of the element
        //!Considers horizontal alignment, x offset, width, and parent element's GetLeft() / GetWidth() values
        //!\return left coordinate
        int GetLeft();
        //!Gets the current topmost coordinate of the element
        //!Considers vertical alignment, y offset, height, and parent element's GetTop() / GetHeight() values
        //!\return top coordinate
        int GetTop();
        //!Sets the minimum y offset of the element
        //!\param y Y offset
        void SetMinY( int y );
        //!Gets the minimum y offset of the element
        //!\return Minimum Y offset
        int GetMinY();
        //!Sets the maximum y offset of the element
        //!\param y Y offset
        void SetMaxY( int y );
        //!Gets the maximum y offset of the element
        //!\return Maximum Y offset
        int GetMaxY();
        //!Sets the minimum x offset of the element
        //!\param x X offset
        void SetMinX( int x );
        //!Gets the minimum x offset of the element
        //!\return Minimum X offset
        int GetMinX();
        //!Sets the maximum x offset of the element
        //!\param x X offset
        void SetMaxX( int x );
        //!Gets the maximum x offset of the element
        //!\return Maximum X offset
        int GetMaxX();
        //!Gets the current width of the element. Does not currently consider the scale
        //!\return width
        int GetWidth();
        //!Gets the height of the element. Does not currently consider the scale
        //!\return height
        int GetHeight();
        //!Sets the size (width/height) of the element
        //!\param w Width of element
        //!\param h Height of element
        void SetSize( int w, int h );
        //!Checks whether or not the element is visible
        //!\return true if visible, false otherwise
        bool IsVisible();
        //!Checks whether or not the element is selectable
        //!\return true if selectable, false otherwise
        bool IsSelectable();
        //!Checks whether or not the element is clickable
        //!\return true if clickable, false otherwise
        bool IsClickable();
        //!Checks whether or not the element is holdable
        //!\return true if holdable, false otherwise
        bool IsHoldable();
        //!Sets whether or not the element is selectable
        //!\param s Selectable
        void SetSelectable( bool s );
        //!Sets whether or not the element is clickable
        //!\param c Clickable
        void SetClickable( bool c );
        //!Sets whether or not the element is holdable
        //!\param c Holdable
        void SetHoldable( bool d );
        //!Gets the element's current state
        //!\return state
        int GetState();
        //!Gets the controller channel that last changed the element's state
        //!\return Channel number (0-3, -1 = no channel)
        int GetStateChan();
        //!Sets the element's alpha value
        //!\param a alpha value
        void SetAlpha( int a );
        //!Gets the element's alpha value
        //!Considers alpha, alphaDyn, and the parent element's GetAlpha() value
        //!\return alpha
        int GetAlpha();
        //!Gets the element's AngleDyn value
        //!\return alpha
        float GetAngleDyn();
        //!Sets the element's scale
        //!\param s scale (1 is 100%)
        void SetScale( float s );
        //!Gets the element's current scale
        //!Considers scale, scaleDyn, and the parent element's GetScale() value
        virtual float GetScale();
        //!Set a new GuiTrigger for the element
        //!\param t Pointer to GuiTrigger
        void SetTrigger( GuiTrigger * t );
        //!\overload
        //!\param i Index of trigger array to set
        //!\param t Pointer to GuiTrigger
        void SetTrigger( u8 i, GuiTrigger * t );
        //!Remove GuiTrigger for the element
        //!\param i Index of trigger array to set
        void RemoveTrigger( u8 i );
        //!Checks whether rumble was requested by the element
        //!\return true is rumble was requested, false otherwise
        bool Rumble();
        //!Sets whether or not the element is requesting a rumble event
        //!\param r true if requesting rumble, false if not
        void SetRumble( bool r );
        //!Set an effect for the element
        //!\param e Effect to enable
        //!\param a Amount of the effect (usage varies on effect)
        //!\param t Target amount of the effect (usage varies on effect)
        void SetEffect( int e, int a, int t = 0 );
        //!This SetEffect is for EFFECT_GOROUND only
        //!\param e Effect to enable
        //!\param speed is for Circlespeed
        //!\param circles Circleamount in degree ike 180 for 1/2 circle or 720 for 2 circles
        //!\param r Circle Radius in pixel
        //!\param startdegree Degree where to start circling
        //!\param anglespeedset Set the speed of Angle rotating make 1 for same speed as Circlespeed
        //!       or 0.5 for half the speed of the circlingspeed. Turn Anglecircling off by 0 to this param.
        //!\param center_x x co-ordinate of the center of circle.
        //!\param center_y y co-ordinate of the center of circle.
        void SetEffect( int e, int speed, f32 circles, int r, f32 startdegree, f32 anglespeedset, int center_x, int center_y );
        //!Gets the frequency from the above effect
        //!\return element frequency
        float GetFrequency();
        //!Sets an effect to be enabled on wiimote cursor over
        //!\param e Effect to enable
        //!\param a Amount of the effect (usage varies on effect)
        //!\param t Target amount of the effect (usage varies on effect)
        void SetEffectOnOver( int e, int a, int t = 0 );
        //!Shortcut to SetEffectOnOver(EFFECT_SCALE, 4, 110)
        void SetEffectGrow();
        //!Stops the current element effect
        void StopEffect();
        //!Gets the current element effects
        //!\return element effects
        int GetEffect();
        //!Gets the current element on over effects
        //!\return element on over effects
        int GetEffectOnOver();
        //!Checks whether the specified coordinates are within the element's boundaries
        //!\param x X coordinate
        //!\param y Y coordinate
        //!\return true if contained within, false otherwise
        bool IsInside( int x, int y );
        //!Sets the element's position
        //!\param x X coordinate
        //!\param y Y coordinate
        void SetPosition( int x, int y, int z = 0 );
        //!Updates the element's effects (dynamic values)
        //!Called by Draw(), used for animation purposes
        void UpdateEffects();
        //!Sets a function to called after after Update()
        //!Callback function can be used to response to changes in the state of the element, and/or update the element's attributes
        void SetUpdateCallback( UpdateCallback u );
        //!Checks whether the element is in focus
        //!\return true if element is in focus, false otherwise
        int IsFocused();
        //!Sets the element's visibility
        //!\param v Visibility (true = visible)
        virtual void SetVisible( bool v );
        //!Sets the element's focus
        //!\param f Focus (true = in focus)
        virtual void SetFocus( int f );
        //!Sets the element's state
        //!\param s State (STATE_DEFAULT, STATE_SELECTED, STATE_CLICKED, STATE_DISABLED)
        //!\param c Controller channel (0-3, -1 = none)
        virtual void SetState( int s, int c = -1 );
        //!Resets the element's state to STATE_DEFAULT
        virtual void ResetState();
        //!Gets whether or not the element is in STATE_SELECTED
        //!\return true if selected, false otherwise
        virtual int GetSelected();
        //!Sets the element's alignment respective to its parent element
        //!\param hor Horizontal alignment (ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTRE)
        //!\param vert Vertical alignment (ALIGN_TOP, ALIGN_BOTTOM, ALIGN_MIDDLE)
        virtual void SetAlignment( int hor, int vert );
        //!Called constantly to allow the element to respond to the current input data
        //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
        virtual void Update( GuiTrigger * t );
        //!Called constantly to redraw the element
        virtual void Draw();
        virtual void DrawTooltip();
    protected:
        void Lock();
        void Unlock();
//      static mutex_t mutex;
        static mutex_t  _lock_mutex;
        lwp_t   _lock_thread;
        u16     _lock_count;
        lwpq_t  _lock_queue;
        friend class SimpleLock;

        //int position2; //! B Scrollbariable
        bool visible; //!< Visibility of the element. If false, Draw() is skipped
        int focus; //!< Element focus (-1 = focus disabled, 0 = not focused, 1 = focused)
        int dontsetfocus; //!<If 0 games dont set the focus
        int width; //!< Element width
        int height; //!< Element height
        int xoffset; //!< Element X offset
        int yoffset; //!< Element Y offset
        int zoffset; //!< Element Z offset
        int ymin; //!< Element's min Y offset allowed
        int ymax; //!< Element's max Y offset allowed
        int xmin; //!< Element's min X offset allowed
        int xmax; //!< Element's max X offset allowed
        int xoffsetDyn; //!< Element X offset, dynamic (added to xoffset value for animation effects)
        int yoffsetDyn; //!< Element Y offset, dynamic (added to yoffset value for animation effects)
        int temp_xoffset; //!< Element Temp X offset
        int temp_yoffset; //!< Element Temp Y offset
        f32 degree; //!< Degree where to start for EFFECT_GOROUND enter it in <20> like 60<36>
        f32 frequency; //!< Speed for EFFECT_GOROUND || can also be negative for other direction
        int Radius; //!< The radius in which the Element goes round for EFFECT_GOROUND
        f32 circleamount; //!< Circleamount for the EFFECT_GOROUND effect
        f32 xoffsetDynFloat; //!< Integer sucks float is need by some parts
        f32 yoffsetDynFloat; //!< Integer sucks float is need by some parts
        int changervar; //!< Changervariable for some stuff
        int alpha; //!< Element alpha value (0-255)
        f32 scale; //!< Element scale (1 = 100%)
        f32 angleDyn; //!< AngleDyn for EFFECT_GOROUND
        f32 anglespeed; //!<Anglespeedvariable for EFFECT_GOROUND
        int alphaDyn; //!< Element alpha, dynamic (multiplied by alpha value for blending/fading effects)
        f32 scaleDyn; //!< Element scale, dynamic (multiplied by alpha value for blending/fading effects)
        bool rumble; //!< Wiimote rumble (on/off) - set to on when this element requests a rumble event
        int effects; //!< Currently enabled effect(s). 0 when no effects are enabled
        int effectAmount; //!< Effect amount. Used by different effects for different purposes
        int effectTarget; //!< Effect target amount. Used by different effects for different purposes
        int effectsOver; //!< Effects to enable when wiimote cursor is over this element. Copied to effects variable on over event
        int effectAmountOver; //!< EffectAmount to set when wiimote cursor is over this element
        int effectTargetOver; //!< EffectTarget to set when wiimote cursor is over this element
        int alignmentHor; //!< Horizontal element alignment, respective to parent element (LEFT, RIGHT, CENTRE)
        int alignmentVert; //!< Horizontal element alignment, respective to parent element (TOP, BOTTOM, MIDDLE)
        int state; //!< Element state (DEFAULT, SELECTED, CLICKED, DISABLED)
        int stateChan; //!< Which controller channel is responsible for the last change in state
        bool selectable; //!< Whether or not this element selectable (can change to SELECTED state)
        bool clickable; //!< Whether or not this element is clickable (can change to CLICKED state)
        bool holdable; //!< Whether or not this element is holdable (can change to HELD state)
        GuiTrigger * trigger[6]; //!< GuiTriggers (input actions) that this element responds to
        GuiElement * parentElement; //!< Parent element
        UpdateCallback updateCB; //!< Callback function to call when this element is updated
};
class SimpleLock
{
    public:
        SimpleLock( GuiElement *e );
        ~SimpleLock();
    private:
        GuiElement *element;
};
#define LOCK(e) SimpleLock LOCK(e)

//!Allows GuiElements to be grouped together into a "window"
class GuiWindow : public GuiElement
{
    public:
        //!Constructor
        GuiWindow();
        //!\overload
        //!\param w Width of window
        //!\param h Height of window
        GuiWindow( int w, int h );
        //!Destructor
        ~GuiWindow();
        //!Appends a GuiElement to the GuiWindow
        //!\param e The GuiElement to append. If it is already in the GuiWindow, it is removed first
        void Append( GuiElement* e );
        //!Inserts a GuiElement into the GuiWindow at the specified index
        //!\param e The GuiElement to insert. If it is already in the GuiWindow, it is removed first
        //!\param i Index in which to insert the element
        void Insert( GuiElement* e, u32 i );
        //!Removes the specified GuiElement from the GuiWindow
        //!\param e GuiElement to be removed
        void Remove( GuiElement* e );
        //!Removes all GuiElements
        void RemoveAll();
        //!Returns the GuiElement at the specified index
        //!\param index The index of the element
        //!\return A pointer to the element at the index, NULL on error (eg: out of bounds)
        GuiElement* GetGuiElementAt( u32 index ) const;
        //!Returns the size of the list of elements
        //!\return The size of the current element list
        u32 GetSize();
        //!Sets the visibility of the window
        //!\param v visibility (true = visible)
        void SetVisible( bool v );
        //!Resets the window's state to STATE_DEFAULT
        void ResetState();
        //!Sets the window's state
        //!\param s State
        void SetState( int s );
        //!Gets the index of the GuiElement inside the window that is currently selected
        //!\return index of selected GuiElement
        int GetSelected();
        //!Sets the window focus
        //!\param f Focus
        void SetFocus( int f );
        //!Change the focus to the specified element
        //!This is intended for the primary GuiWindow only
        //!\param e GuiElement that should have focus
        void ChangeFocus( GuiElement * e );
        //!Changes window focus to the next focusable window or element
        //!If no element is in focus, changes focus to the first available element
        //!If B or 1 button is pressed, changes focus to the next available element
        //!This is intended for the primary GuiWindow only
        //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
        void ToggleFocus( GuiTrigger * t );
        //!Moves the selected element to the element to the left or right
        //!\param d Direction to move (-1 = left, 1 = right)
        void MoveSelectionHor( int d );
        //!Moves the selected element to the element above or below
        //!\param d Direction to move (-1 = up, 1 = down)
        void MoveSelectionVert( int d );
        //!Draws all the elements in this GuiWindow
        void Draw();
        void DrawTooltip();
        //!Updates the window and all elements contains within
        //!Allows the GuiWindow and all elements to respond to the input data specified
        //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
        void Update( GuiTrigger * t );
    protected:
        std::vector<GuiElement*> _elements; //!< Contains all elements within the GuiWindow
};

//!Converts image data into GX-useable RGBA8. Currently designed for use only with PNG files
class GuiImageData
{
    public:
        //!Constructor
        //!Converts the image data to RGBA8 - expects PNG format
        //!\param i Image data
        GuiImageData( const u8 * i );
        GuiImageData( const char * imgPath, const u8 * buffer );
        GuiImageData( const u8 * img, int imgSize );
        GuiImageData( const char *path, const char *file, const u8 * buffer, bool force_widescreen = false, const u8 * wbuffer = NULL );
        //!Destructor
        ~GuiImageData();
        //!Gets a pointer to the image data
        //!\return pointer to image data
        u8 * GetImage();
        //!Gets the image width
        //!\return image width
        int GetWidth();
        //!Gets the image height
        //!\return image height
        int GetHeight();
        //!LoadJpeg file
        void LoadJpeg( const u8 *img, int imgSize );
        //!RawTo4x4RGBA
        void RawTo4x4RGBA( const unsigned char *src, void *dst, const unsigned int width, const unsigned int height );
        //!Sets the image to grayscale
        void SetGrayscale( void );
    protected:
        u8 * data; //!< Image data
        int height; //!< Height of image
        int width; //!< Width of image
};

//!Display, manage, and manipulate images in the GUI
class GuiImage : public GuiElement
{
    public:
        //!Constructor
        GuiImage();
        //!\overload
        //!\param img Pointer to GuiImageData element
        GuiImage( GuiImageData * img );
        //!\overload
        //!Sets up a new image from the image data specified
        //!\param img
        //!\param w Image width
        //!\param h Image height
        GuiImage( u8 * img, int w, int h );
        //!\overload
        //!Creates an image filled with the specified color
        //!\param w Image width
        //!\param h Image height
        //!\param c Image color
        GuiImage( int w, int h, GXColor c );
        //! Copy Constructor
        GuiImage( GuiImage &srcimage );
        GuiImage( GuiImage *srcimage );
        //! = operator for copying images
        GuiImage &operator=( GuiImage &srcimage );
        //!Destructor
        ~GuiImage();
        //!Sets the image rotation angle for drawing
        //!\param a Angle (in degrees)
        void SetAngle( float a );
        //!Gets the image rotation angle for drawing
        float GetAngle();
        //!Sets the number of times to draw the image horizontally
        //!\param t Number of times to draw the image
        void SetTile( int t );
        // true set horizontal scale to 0.8 //added
        void SetWidescreen( bool w );
        //!Constantly called to draw the image
        void Draw();
        //!Gets the image data
        //!\return pointer to image data
        u8 * GetImage();
        //!Sets up a new image using the GuiImageData object specified
        //!\param img Pointer to GuiImageData object
        void SetImage( GuiImageData * img );
        //!\overload
        //!\param img Pointer to image data
        //!\param w Width
        //!\param h Height
        void SetImage( u8 * img, int w, int h );
        //!Gets the pixel color at the specified coordinates of the image
        //!\param x X coordinate
        //!\param y Y coordinate
        GXColor GetPixel( int x, int y );
        //!Sets the pixel color at the specified coordinates of the image
        //!\param x X coordinate
        //!\param y Y coordinate
        //!\param color Pixel color
        void SetPixel( int x, int y, GXColor color );
        //!Sets the image to grayscale
        void SetGrayscale( void );
        //!Set/disable the use of parentelement angle (default true)
        void SetParentAngle( bool a );
        //!Directly modifies the image data to create a color-striped effect
        //!Alters the RGB values by the specified amount
        //!\param s Amount to increment/decrement the RGB values in the image
        void ColorStripe( int s );
        //!Sets a stripe effect on the image, overlaying alpha blended rectangles
        //!Does not alter the image data
        //!\param s Alpha amount to draw over the image
        void SetStripe( int s );
        s32 z;
        void SetSkew( int XX1, int YY1, int XX2, int YY2, int XX3, int YY3, int XX4, int YY4 );
        void SetSkew( int *skew /* int skew[8] */ );
        int xx1;
        int yy1;
        int xx2;
        int yy2;
        int xx3;
        int yy3;
        int xx4;
        int yy4;
        int rxx1;
        int ryy1;
        int rxx2;
        int ryy2;
        int rxx3;
        int ryy3;
        int rxx4;
        int ryy4;
    protected:
        int imgType; //!< Type of image data (IMAGE_TEXTURE, IMAGE_COLOR, IMAGE_DATA)
        u8 * image; //!< Poiner to image data. May be shared with GuiImageData data
        f32 imageangle; //!< Angle to draw the image
        int tile; //!< Number of times to draw (tile) the image horizontally
        int stripe; //!< Alpha value (0-255) to apply a stripe effect to the texture
        short widescreen; //added
        bool parentangle;
};
//!Display, manage, and manipulate text in the GUI
class GuiText : public GuiElement
{
    public:
        //!Constructor
        //!\param t Text
        //!\param s Font size
        //!\param c Font color
        GuiText( const char * t, int s, GXColor c );
        //!\overload
        //!\param t Text
        //!\param s Font size
        //!\param c Font color
        GuiText( const wchar_t * t, int s, GXColor c );
        //!\overload
        //!\Assumes SetPresets() has been called to setup preferred text attributes
        //!\param t Text
        GuiText( const char * t );
        //!Destructor
        ~GuiText();
        //!Sets the text of the GuiText element
        //!\param t Text
        virtual void SetText( const char * t );
        virtual void SetText( const wchar_t * t );
        virtual void SetTextf( const char *format, ... ) __attribute__( ( format( printf, 2, 3 ) ) );
        //!Sets up preset values to be used by GuiText(t)
        //!Useful when printing multiple text elements, all with the same attributes set
        //!\param sz Font size
        //!\param c Font color
        //!\param w Maximum width of texture image (for text wrapping)
        //!\param wrap Wrapmode when w>0
        //!\param s Font style
        //!\param h Text alignment (horizontal)
        //!\param v Text alignment (vertical)
        static void SetPresets( int sz, GXColor c, int w, u16 s, int h, int v );
        //!Sets the font size
        //!\param s Font size
        void SetFontSize( int s );
        //!Sets the maximum width of the drawn texture image
        //!If the text exceeds this, it is wrapped to the next line
        //!\param w Maximum width
        //!\param m WrapMode
        void SetMaxWidth( int w = 0, int m = WRAP );
        //!Sets the font color
        //!\param c Font color
        void SetColor( GXColor c );
        //!Sets the FreeTypeGX style attributes
        //!\param s Style attributes
        //!\param m Style-Mask attributes
        void SetStyle( u16 s );
        //!Sets the text alignment
        //!\param hor Horizontal alignment (ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTRE)
        //!\param vert Vertical alignment (ALIGN_TOP, ALIGN_BOTTOM, ALIGN_MIDDLE)
        void SetAlignment( int hor, int vert );
        //!Set PassChar
        void SetPassChar( wchar_t p );
        //!Sets the font
        //!\param f Font
        void SetFont( FreeTypeGX *f );
        //!Get the original text as char
        virtual const wchar_t * GetText();
        //!Get the Horizontal Size of Text
        int GetTextWidth();
        int GetTextWidth( int ind );
        //!Get the max textwidth
        int GetTextMaxWidth();
        //!Gets the total line number
        virtual int GetLinesCount() { return 1; };
        //!Get fontsize
        int GetFontSize() { return size; };
        //!Set max lines to draw
        void SetLinesToDraw( int l );
        void SetWidescreen( bool b ) { widescreen = b; };
        //!Get current Textline (for position calculation)
        const wchar_t * GetDynText( int ind = 0 );
        virtual const wchar_t * GetTextLine( int ind ) { return GetDynText( ind ); };
        //!Change the font
        //!\param font bufferblock
        //!\param font filesize
        bool SetFont( const u8 *font, const u32 filesize );
        //!Constantly called to draw the text
        void Draw();
    protected:
        //!Clear the dynamic text
        void ClearDynamicText();
        //!Create a dynamic dotted text if the text is too long
        void MakeDottedText();
        //!Scroll the text once
        void ScrollText();
        //!Wrap the text to several lines
        void WrapText();

        wchar_t *text;
        std::vector<wchar_t *> textDyn;
        int wrapMode; //!< Wrapping toggle
        int textScrollPos; //!< Current starting index of text string for scrolling
        int textScrollInitialDelay; //!< Delay to wait before starting to scroll
        int textScrollDelay; //!< Scrolling speed
        int size; //!< Font size
        int maxWidth; //!< Maximum width of the generated text object (for text wrapping)
        u16 style; //!< FreeTypeGX style attributes
        GXColor color; //!< Font color
        FreeTypeGX *font;
        int textWidth;
        int currentSize;
        int linestodraw;
        wchar_t passChar;
        bool widescreen;
};

//!Display, manage, and manipulate tooltips in the GUI.
class GuiTooltip : public GuiElement
{
    public:
        //!Constructor
        //!\param t Text
        GuiTooltip( const char *t, int Alpha = 255 );

        //!Destructor
        ~ GuiTooltip();

        //!Gets the element's current scale
        //!Considers scale, scaleDyn, and the parent element's GetScale() value
        float GetScale();
        //!Sets the text of the GuiTooltip element
        //!\param t Text
        void SetText( const char * t );
        void SetWidescreen( bool w ); // timely a dummy
        //!Constantly called to draw the GuiButton
        void Draw();

    protected:
        GuiImage leftImage; //!< Tooltip left-image
        GuiImage tileImage; //!< Tooltip tile-image
        GuiImage rightImage; //!< Tooltip right-image
        GuiText *text;
};


//!Display, manage, and manipulate buttons in the GUI. Buttons can have images, icons, text, and sound set (all of which are optional)
class GuiButton : public GuiElement
{
    public:
        //!Constructor
        //!\param w Width
        //!\param h Height
        GuiButton( int w, int h );
        //!\param img is the button GuiImage.  it uses the height & width of this image for the button
        //!\param imgOver is the button's over GuiImage
        //!\param hor is horizontal alingment of the button
        //!\param vert is verticle alignment of the button
        //!\param x is xposition of the button
        //!\param y is yposition of the button
        //!\param trig is a GuiTrigger to assign to this button
        //!\param sndOver is a GuiSound used for soundOnOver for this button
        //!\param sndClick is a GuiSound used for clickSound of this button
        //!\param grow sets effect grow for this button.  1 for yes ;0 for no
        GuiButton( GuiImage* img, GuiImage* imgOver, int hor, int vert, int x, int y, GuiTrigger* trig, GuiSound* sndOver, GuiSound* sndClick, u8 grow );
        //!\param same as all the parameters for the above button plus the following
        //!\param tt is a GuiTooltip assigned to this button
        //!\param ttx and tty are the xPOS and yPOS for this tooltip in relationship to the button
        //!\param h_align and v_align are horizontal and verticle alignment for the tooltip in relationship to the button
        GuiButton( GuiImage* img, GuiImage* imgOver, int hor, int vert, int x, int y, GuiTrigger* trig, GuiSound* sndOver, GuiSound* sndClick, u8 grow, GuiTooltip* tt, int ttx, int tty, int h_align, int v_align );
        //!Destructor
        ~GuiButton();
        //!Sets the button's image
        //!\param i Pointer to GuiImage object
        void SetImage( GuiImage* i );
        //!Sets the button's image on over
        //!\param i Pointer to GuiImage object
        void SetImageOver( GuiImage* i );
        //!Sets the button's image on hold
        //!\param i Pointer to GuiImage object
        void SetAngle( float a );
        void SetImageHold( GuiImage* i );
        //!Sets the button's image on click
        //!\param i Pointer to GuiImage object
        void SetImageClick( GuiImage* i );
        //!Sets the button's icon
        //!\param i Pointer to GuiImage object
        void SetIcon( GuiImage* i );
        //!Sets the button's icon on over
        //!\param i Pointer to GuiImage object
        void SetIconOver( GuiImage* i );
        //!Sets the button's icon on hold
        //!\param i Pointer to GuiImage object
        void SetIconHold( GuiImage* i );
        //!Sets the button's icon on click
        //!\param i Pointer to GuiImage object
        void SetIconClick( GuiImage* i );
        //!Sets the button's label
        //!\param t Pointer to GuiText object
        //!\param n Index of label to set (optional, default is 0)
        void SetLabel( GuiText* t, int n = 0 );
        //!Sets the button's label on over (eg: different colored text)
        //!\param t Pointer to GuiText object
        //!\param n Index of label to set (optional, default is 0)
        void SetLabelOver( GuiText* t, int n = 0 );
        //!Sets the button's label on hold
        //!\param t Pointer to GuiText object
        //!\param n Index of label to set (optional, default is 0)
        void SetLabelHold( GuiText* t, int n = 0 );
        //!Sets the button's label on click
        //!\param t Pointer to GuiText object
        //!\param n Index of label to set (optional, default is 0)
        void SetLabelClick( GuiText* t, int n = 0 );
        //!Sets the sound to play on over
        //!\param s Pointer to GuiSound object
        void SetSoundOver( GuiSound * s );
        //!Sets the sound to play on hold
        //!\param s Pointer to GuiSound object
        void SetSoundHold( GuiSound * s );
        //!Sets the sound to play on click
        //!\param s Pointer to GuiSound object
        void SetSoundClick( GuiSound * s );
        //!\param reset the soundover to NULL
        void RemoveSoundOver();
        //!\param reset the soundclick to NULL
        void RemoveSoundClick();
        //!Constantly called to draw the GuiButtons ToolTip
        //!Sets the button's Tooltip on over
        //!\param tt Pointer to GuiElement object, x & y Positioning, h & v Align
        void SetToolTip( GuiTooltip* tt, int x, int y, int h = ALIGN_RIGHT, int v = ALIGN_TOP );

        void RemoveToolTip();
        //!Constantly called to draw the GuiButton
        void Draw();
        void DrawTooltip();
        //!Constantly called to allow the GuiButton to respond to updated input data
        //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
        void Update( GuiTrigger * t );
        //!Deactivate/Activate pointing on Games while B scrolling
        void ScrollIsOn( int f );
        void SetSkew( int XX1, int YY1, int XX2, int YY2, int XX3, int YY3, int XX4, int YY4 );
        void SetSkew( int *skew /* int skew[8] */ );
    protected:
        GuiImage * image; //!< Button image (default)
        GuiImage * imageOver; //!< Button image for STATE_SELECTED
        GuiImage * imageHold; //!< Button image for STATE_HELD
        GuiImage * imageClick; //!< Button image for STATE_CLICKED
        GuiImage * icon; //!< Button icon (drawn after button image)
        GuiImage * iconOver; //!< Button icon for STATE_SELECTED
        GuiImage * iconHold; //!< Button icon for STATE_HELD
        GuiImage * iconClick; //!< Button icon for STATE_CLICKED
        GuiTooltip *toolTip;
        time_t time1, time2;//!< Tooltip timeconstants
        GuiText * label[3]; //!< Label(s) to display (default)
        GuiText * labelOver[3]; //!< Label(s) to display for STATE_SELECTED
        GuiText * labelHold[3]; //!< Label(s) to display for STATE_HELD
        GuiText * labelClick[3]; //!< Label(s) to display for STATE_CLICKED
        GuiSound * soundOver; //!< Sound to play for STATE_SELECTED
        GuiSound * soundHold; //!< Sound to play for STATE_HELD
        GuiSound * soundClick; //!< Sound to play for STATE_CLICKED
};

typedef struct _keytype
{
    char ch, chShift, chalt, chalt2;
} Key;

//!On-screen keyboard
class GuiKeyboard : public GuiWindow
{
    public:
        GuiKeyboard( char * t, u32 m, int min, int lang );
        ~GuiKeyboard();
        void Update( GuiTrigger * t );
        char kbtextstr[256];
    protected:
        u32 kbtextmaxlen;
        Key keys[4][11];
        int shift;
        int caps;
        int alt;
        int alt2;
        GuiText * kbText;
        GuiImage * keyTextboxImg;
        GuiText * keyCapsText;
        GuiImage * keyCapsImg;
        GuiImage * keyCapsOverImg;
        GuiButton * keyCaps;
        GuiText * keyAltText;
        GuiImage * keyAltImg;
        GuiImage * keyAltOverImg;
        GuiButton * keyAlt;
        GuiText * keyAlt2Text;
        GuiImage * keyAlt2Img;
        GuiImage * keyAlt2OverImg;
        GuiButton * keyAlt2;
        GuiText * keyShiftText;
        GuiImage * keyShiftImg;
        GuiImage * keyShiftOverImg;
        GuiButton * keyShift;
        GuiText * keyBackText;
        GuiImage * keyBackImg;
        GuiImage * keyBackOverImg;
        GuiButton * keyBack;
        GuiText * keyClearText;
        GuiImage * keyClearImg;
        GuiImage * keyClearOverImg;
        GuiButton * keyClear;
        GuiImage * keySpaceImg;
        GuiImage * keySpaceOverImg;
        GuiButton * keySpace;
        GuiButton * keyBtn[4][11];
        GuiImage * keyImg[4][11];
        GuiImage * keyImgOver[4][11];
        GuiText * keyTxt[4][11];
        GuiImageData * keyTextbox;
        GuiImageData * key;
        GuiImageData * keyOver;
        GuiImageData * keyMedium;
        GuiImageData * keyMediumOver;
        GuiImageData * keyLarge;
        GuiImageData * keyLargeOver;
        GuiSound * keySoundOver;
        GuiSound * keySoundClick;
        GuiTrigger * trigA;
        GuiTrigger * trigB;
};

//!On-screen keyboard
class GuiNumpad : public GuiWindow
{
    public:
        GuiNumpad( char * t, u32 max );
        ~GuiNumpad();
        void Update( GuiTrigger * t );
        char kbtextstr[256];
    protected:
        u32 kbtextmaxlen;
        char keys[11];
        GuiText * kbText;
        GuiImage * keyTextboxImg;

        GuiText * keyBackText;
        GuiImage * keyBackImg;
        GuiImage * keyBackOverImg;
        GuiButton * keyBack;
        GuiText * keyClearText;
        GuiImage * keyClearImg;
        GuiImage * keyClearOverImg;
        GuiButton * keyClear;
        GuiButton * keyBtn[11];
        GuiImage * keyImg[11];
        GuiImage * keyImgOver[11];
        GuiText * keyTxt[11];
        GuiImageData * keyTextbox;
        GuiImageData * keyMedium;
        GuiImageData * keyMediumOver;
        GuiSound * keySoundOver;
        GuiSound * keySoundClick;
        GuiTrigger * trigA;
        GuiTrigger * trigB;
};

typedef struct _optionlist
{
    int length;
    char name[MAX_OPTIONS][60];
    char value[MAX_OPTIONS][30];
} OptionList;

//!Display a list of menu options
class GuiOptionBrowser : public GuiElement
{
    public:
        GuiOptionBrowser( int w, int h, OptionList * l, const u8 *imagebg, int scrollbar );
        GuiOptionBrowser( int w, int h, OptionList * l, const char * themePath, const u8 *imagebg, int scrollbar, int start );
        ~GuiOptionBrowser();
        void SetCol2Position( int x );
        int FindMenuItem( int c, int d );
        int GetClickedOption();
        int GetSelectedOption();
        void ResetState();
        void SetFocus( int f );
        void Draw();
        void TriggerUpdate();
        void Update( GuiTrigger * t );
        GuiText * optionVal[PAGESIZE];
    protected:
        int selectedItem;
        int listOffset;
        bool listChanged;
        OptionList * options;
        int optionIndex[PAGESIZE];
        GuiButton * optionBtn[PAGESIZE];
        GuiText * optionTxt[PAGESIZE];
        GuiImage * optionBg[PAGESIZE];

        GuiButton * arrowUpBtn;
        GuiButton * arrowDownBtn;
        GuiButton * scrollbarBoxBtn;

        GuiImage * bgOptionsImg;
        GuiImage * bgOptionsOverImg;
        GuiImage * scrollbarImg;
        GuiImage * arrowDownImg;
        GuiImage * arrowDownOverImg;
        GuiImage * arrowUpImg;
        GuiImage * arrowUpOverImg;
        GuiImage * scrollbarBoxImg;
        GuiImage * scrollbarBoxOverImg;

        GuiImageData * bgOptions;
        GuiImageData * bgOptionsOver;
        GuiImageData * bgOptionsEntry;
        GuiImageData * scrollbar;
        GuiImageData * arrowDown;
        GuiImageData * arrowDownOver;
        GuiImageData * arrowUp;
        GuiImageData * arrowUpOver;
        GuiImageData * scrollbarBox;
        GuiImageData * scrollbarBoxOver;

        GuiSound * btnSoundOver;
        GuiSound * btnSoundClick;
        GuiTrigger * trigA;
        GuiTrigger * trigB;
        GuiTrigger * trigHeldA;
};

//!Display a list of files
class GuiFileBrowser : public GuiElement
{
    public:
        GuiFileBrowser( int w, int h );
        ~GuiFileBrowser();
        void DisableTriggerUpdate( bool set );
        void ResetState();
        void SetFocus( int f );
        void Draw();
        void TriggerUpdate();
        void Update( GuiTrigger * t );
        GuiButton * fileList[PAGESIZE];
    protected:
        int selectedItem;
        bool listChanged;
        bool triggerdisabled;

        GuiText * fileListText[PAGESIZE];
        GuiText * fileListTextOver[PAGESIZE];
        GuiImage * fileListBg[PAGESIZE];
        //GuiImage * fileListArchives[PAGESIZE];
        //GuiImage * fileListDefault[PAGESIZE];
        GuiImage * fileListFolder[PAGESIZE];
        //GuiImage * fileListGFX[PAGESIZE];
        //GuiImage * fileListPLS[PAGESIZE];
        //GuiImage * fileListSFX[PAGESIZE];
        //GuiImage * fileListTXT[PAGESIZE];
        //GuiImage * fileListXML[PAGESIZE];

        GuiButton * arrowUpBtn;
        GuiButton * arrowDownBtn;
        GuiButton * scrollbarBoxBtn;

        GuiImage * bgFileSelectionImg;
        GuiImage * scrollbarImg;
        GuiImage * arrowDownImg;
        GuiImage * arrowUpImg;
        GuiImage * scrollbarBoxImg;

        GuiImageData * bgFileSelection;
        GuiImageData * bgFileSelectionEntry;
        //GuiImageData * fileArchives;
        //GuiImageData * fileDefault;
        GuiImageData * fileFolder;
        //GuiImageData * fileGFX;
        //GuiImageData * filePLS;
        //GuiImageData * fileSFX;
        //GuiImageData * fileTXT;
        //GuiImageData * fileXML;
        GuiImageData * scrollbar;
        GuiImageData * arrowDown;
        GuiImageData * arrowUp;
        GuiImageData * scrollbarBox;

        GuiSound * btnSoundOver;
        GuiSound * btnSoundClick;
        GuiTrigger * trigA;
        GuiTrigger * trigHeldA;
};

#endif