mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-12-23 10:21:55 +01:00
72d8c9dc2e
*Created an own class for the homebrew prompt *Created scrollbar class which is now used on every browser *Created a checkbox browser list class *Changed the category prompts to the new list mode *Improved B-Button scrolling *Fixed horizontal text scrolling *Fixed possible crash on long text display *Many internal gui changes and navigation changes *Fixed booting games by argument (headless id) (Issue 1930) *Fixed SD Reload button to really reload the SD after it was ejected (Issue 1923) *Added booting with arguements from meta.xml for homebrews (Issue 1926) *Added some arguments acception from meta.xml to our app. "-ios=xxx" and "-usbport=x" or "--ios=xxx" and "--usbport=x" can be used. -usbport is for Hermes cIOS to decide which usb port to use on startup. The ios is the boot IOS on startup, it always overrides the compiled boot IOS into the application.
982 lines
41 KiB
C++
982 lines
41 KiB
C++
/****************************************************************************
|
|
* LibWiiGui by Tantric (C) 2009
|
|
* USB Loader GX Team (C) 2009-2011
|
|
*
|
|
* The LibWiiGui library was used as the base for the creation of
|
|
* the GUI in USB Loader GX.
|
|
* Several modifications and additions were made to the library
|
|
* It does no longer match the original LibWiiGui implementation.
|
|
*
|
|
* This software is provided 'as-is', without any express or implied
|
|
* warranty. In no event will the authors be held liable for any
|
|
* damages arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any
|
|
* purpose, including commercial applications, and to alter it and
|
|
* redistribute it freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you
|
|
* must not claim that you wrote the original software. If you use
|
|
* this software in a product, an acknowledgment in the product
|
|
* documentation would be appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and
|
|
* must not be misrepresented as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source
|
|
* distribution.
|
|
***************************************************************************/
|
|
#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 "gui_imagedata.h"
|
|
#include "FreeTypeGX.h"
|
|
#include "video.h"
|
|
#include "input.h"
|
|
#include "OptionList.hpp"
|
|
#include "SoundOperations/gui_sound.h"
|
|
#include "SoundOperations/gui_bgm.h"
|
|
#include "sigslot.h"
|
|
|
|
//! Frequently used variables
|
|
extern FreeTypeGX *fontSystem;
|
|
extern GuiSound *btnSoundClick;
|
|
extern GuiSound *btnSoundClick2;
|
|
extern GuiSound *btnSoundOver;
|
|
extern GuiBGM *bgMusic;
|
|
|
|
#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 _POINT {
|
|
s16 x;
|
|
s16 y;
|
|
} POINT;
|
|
|
|
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
|
|
|
|
//!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
|
|
virtual int GetWidth();
|
|
//!Gets the height of the element. Does not currently consider the scale
|
|
//!\return height
|
|
virtual 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);
|
|
//!Sets the element's relative position
|
|
int GetRelLeft();
|
|
int GetRelTop();
|
|
//!Sets the element's setup position
|
|
int GetLeftPos() const { return xoffset; }
|
|
int GetTopPos() const { return yoffset; }
|
|
//!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 LockElement();
|
|
void UnlockElement();
|
|
// 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 ° like 60°
|
|
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);
|
|
//!Allow dim of screen on disable or not
|
|
void SetAllowDim(bool d) { allowDim = d; }
|
|
void SetDimScreen(bool d) { forceDim = 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:
|
|
bool forceDim;
|
|
bool allowDim;
|
|
std::vector<GuiElement*> _elements; //!< Contains all elements within the GuiWindow
|
|
};
|
|
|
|
//!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 SetTileHorizontal(int t);
|
|
void SetTileVertical(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 tileHorizontal; //!< Number of times to draw (tile) the image horizontally
|
|
int tileVertical; //!< Number of times to draw (tile) the image vertically
|
|
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();
|
|
//!Overload for GetWidth()
|
|
int GetWidth() { return GetTextWidth(); }
|
|
//!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:
|
|
GuiImageData * tooltipLeft;
|
|
GuiImageData * tooltipTile;
|
|
GuiImageData * tooltipRight;
|
|
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] */);
|
|
virtual void SetState(int s, int c = -1);
|
|
sigslot::signal3<GuiButton *, int, const POINT&> Clicked;
|
|
sigslot::signal3<GuiButton *, int, const POINT&> Held;
|
|
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 * keyLarge;
|
|
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;
|
|
GuiTrigger * trigA;
|
|
GuiTrigger * trigB;
|
|
};
|
|
|
|
#endif
|