usbloadergx/source/libwiigui/gui_element.cpp
ardi@ist-einmalig.de 16b4e62c51
2009-09-27 18:19:53 +00:00

773 lines
14 KiB
C++
Raw Blame History

/****************************************************************************
* libwiigui
*
* Tantric 2009
*
* gui_element.cpp
*
* GUI class definitions
***************************************************************************/
#include "gui.h"
/**
* Constructor for the Object class.
*/
mutex_t GuiElement::mutex = LWP_MUTEX_NULL;
GuiElement::GuiElement()
{
xoffset = 0;
yoffset = 0;
zoffset = 0;
xmin = 0;
xmax = 0;
ymin = 0;
ymax = 0;
width = 0;
height = 0;
alpha = 255;
scale = 1;
state = STATE_DEFAULT;
stateChan = -1;
trigger[0] = NULL;
trigger[1] = NULL;
trigger[2] = NULL;
trigger[3] = NULL;
trigger[4] = NULL;
trigger[6] = NULL;
parentElement = NULL;
rumble = true;
selectable = false;
clickable = false;
holdable = false;
visible = true;
focus = -1; // cannot be focused
updateCB = NULL;
yoffsetDyn = 0;
xoffsetDyn = 0;
yoffsetDynFloat = 0;
alphaDyn = -1;
scaleDyn = 1;
effects = 0;
effectAmount = 0;
effectTarget = 0;
effectsOver = 0;
effectAmountOver = 0;
effectTargetOver = 0;
frequency = 0.0f;
changervar = 0;
degree = -90.0f;
circleamount = 360.0f;
Radius = 150;
angleDyn = 0.0f;
anglespeed = 0.0f;
// default alignment - align to top left
alignmentVert = ALIGN_TOP;
alignmentHor = ALIGN_LEFT;
if(mutex == LWP_MUTEX_NULL) LWP_MutexInit(&mutex, true);
}
/**
* Destructor for the GuiElement class.
*/
GuiElement::~GuiElement()
{
// LWP_MutexDestroy(mutex);
}
void GuiElement::SetParent(GuiElement * e)
{
LOCK(this);
parentElement = e;
}
GuiElement * GuiElement::GetParent()
{
return parentElement;
}
/**
* Get the left position of the GuiElement.
* @see SetLeft()
* @return Left position in pixel.
*/
int GuiElement::GetLeft()
{
int x = 0;
int pWidth = 0;
int pLeft = 0;
if(parentElement)
{
pWidth = parentElement->GetWidth();
pLeft = parentElement->GetLeft();
}
if(effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_GOROUND | EFFECT_ROCK_VERTICLE))
pLeft += xoffsetDyn;
switch(alignmentHor)
{
case ALIGN_LEFT:
x = pLeft;
break;
case ALIGN_CENTRE:
x = pLeft + (pWidth/2) - (width/2);
break;
case ALIGN_RIGHT:
x = pLeft + pWidth - width;
break;
}
return x + xoffset;
}
/**
* Get the top position of the GuiElement.
* @see SetTop()
* @return Top position in pixel.
*/
int GuiElement::GetTop()
{
int y = 0;
int pHeight = 0;
int pTop = 0;
if(parentElement)
{
pHeight = parentElement->GetHeight();
pTop = parentElement->GetTop();
}
if(effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_GOROUND | EFFECT_ROCK_VERTICLE))
pTop += yoffsetDyn;
switch(alignmentVert)
{
case ALIGN_TOP:
y = pTop;
break;
case ALIGN_MIDDLE:
y = pTop + (pHeight/2) - (height/2);
break;
case ALIGN_BOTTOM:
y = pTop + pHeight - height;
break;
}
return y + yoffset;
}
void GuiElement::SetMinX(int x)
{
LOCK(this);
xmin = x;
}
int GuiElement::GetMinX()
{
return xmin;
}
void GuiElement::SetMaxX(int x)
{
LOCK(this);
xmax = x;
}
int GuiElement::GetMaxX()
{
return xmax;
}
void GuiElement::SetMinY(int y)
{
LOCK(this);
ymin = y;
}
int GuiElement::GetMinY()
{
return ymin;
}
void GuiElement::SetMaxY(int y)
{
LOCK(this);
ymax = y;
}
int GuiElement::GetMaxY()
{
return ymax;
}
/**
* Get the width of the GuiElement.
* @see SetWidth()
* @return Width of the GuiElement.
*/
int GuiElement::GetWidth()
{
return width;
}
/**
* Get the height of the GuiElement.
* @see SetHeight()
* @return Height of the GuiElement.
*/
int GuiElement::GetHeight()
{
return height;
}
/**
* Set the width and height of the GuiElement.
* @param[in] Width Width in pixel.
* @param[in] Height Height in pixel.
* @see SetWidth()
* @see SetHeight()
*/
void GuiElement::SetSize(int w, int h)
{
LOCK(this);
width = w;
height = h;
}
/**
* Get visible.
* @see SetVisible()
* @return true if visible, false otherwise.
*/
bool GuiElement::IsVisible()
{
return visible;
}
/**
* Set visible.
* @param[in] Visible Set to true to show GuiElement.
* @see IsVisible()
*/
void GuiElement::SetVisible(bool v)
{
LOCK(this);
visible = v;
}
void GuiElement::SetAlpha(int a)
{
LOCK(this);
alpha = a;
}
int GuiElement::GetAlpha()
{
int a;
if(alphaDyn >= 0)
a = alphaDyn;
else
a = alpha;
if(parentElement)
a *= parentElement->GetAlpha()/255.0;
return a;
}
float GuiElement::GetAngleDyn()
{
float a = 0.0;
if(angleDyn)
a = angleDyn;
if(parentElement && !angleDyn)
a = parentElement->GetAngleDyn();
return a;
}
void GuiElement::SetScale(float s)
{
LOCK(this);
scale = s;
}
float GuiElement::GetScale()
{
float s = scale * scaleDyn;
if(parentElement)
s *= parentElement->GetScale();
return s;
}
int GuiElement::GetState()
{
return state;
}
int GuiElement::GetStateChan()
{
return stateChan;
}
void GuiElement::SetState(int s, int c)
{
LOCK(this);
state = s;
stateChan = c;
}
void GuiElement::ResetState()
{
LOCK(this);
if(state != STATE_DISABLED)
{
state = STATE_DEFAULT;
stateChan = -1;
}
}
void GuiElement::SetClickable(bool c)
{
LOCK(this);
clickable = c;
}
void GuiElement::SetSelectable(bool s)
{
LOCK(this);
selectable = s;
}
void GuiElement::SetHoldable(bool d)
{
LOCK(this);
holdable = d;
}
bool GuiElement::IsSelectable()
{
if(state == STATE_DISABLED || state == STATE_CLICKED)
return false;
else
return selectable;
}
bool GuiElement::IsClickable()
{
if(state == STATE_DISABLED ||
state == STATE_CLICKED ||
state == STATE_HELD)
return false;
else
return clickable;
}
bool GuiElement::IsHoldable()
{
if(state == STATE_DISABLED)
return false;
else
return holdable;
}
void GuiElement::SetFocus(int f)
{
LOCK(this);
focus = f;
}
int GuiElement::IsFocused()
{
return focus;
}
void GuiElement::SetTrigger(GuiTrigger * t)
{
LOCK(this);
if(!trigger[0])
trigger[0] = t;
else if(!trigger[1])
trigger[1] = t;
else if(!trigger[2])
trigger[2] = t;
else if(!trigger[3])
trigger[3] = t;
else if(!trigger[4])
trigger[4] = t;
else if(!trigger[5])
trigger[5] = t;
else // both were assigned, so we'll just overwrite the first one
trigger[0] = t;
}
void GuiElement::SetTrigger(u8 i, GuiTrigger * t)
{
LOCK(this);
trigger[i] = t;
}
void GuiElement::RemoveTrigger(u8 i)
{
LOCK(this);
trigger[i] = NULL;
}
bool GuiElement::Rumble()
{
return rumble;
}
void GuiElement::SetRumble(bool r)
{
LOCK(this);
rumble = r;
}
int GuiElement::GetEffect()
{
LOCK(this);
return effects;
}
int GuiElement::GetEffectOnOver()
{
LOCK(this);
return effectsOver;
}
float GuiElement::GetFrequency()
{
LOCK(this);
return frequency;
}
void GuiElement::SetEffect(int eff, int speed, f32 circles, int r, f32 startdegree, f32 anglespeedset, int center_x, int center_y) {
if(eff & EFFECT_GOROUND) {
xoffsetDyn = 0; //!position of circle in x
yoffsetDyn = 0; //!position of circle in y
Radius = r; //!radius of the circle
degree = startdegree; //!for example -90 (<28>) to start at top of circle
circleamount = circles; //!circleamoutn in degrees for example 360 for 1 circle
angleDyn = 0.0f; //!this is used by the code to calc the angle
anglespeed = anglespeedset; //!This is anglespeed depending on circle speed 1 is same speed and 0.5 half speed
temp_xoffset = center_x; //!position of center in x
temp_yoffset = center_y; //!position of center in y
}
effects |= eff;
effectAmount = speed; //!Circlespeed
}
void GuiElement::SetEffect(int eff, int amount, int target)
{
LOCK(this);
if(eff & EFFECT_SLIDE_IN)
{
// these calculations overcompensate a little
if(eff & EFFECT_SLIDE_TOP)
yoffsetDyn = -screenheight;
else if(eff & EFFECT_SLIDE_LEFT)
xoffsetDyn = -screenwidth;
else if(eff & EFFECT_SLIDE_BOTTOM)
yoffsetDyn = screenheight;
else if(eff & EFFECT_SLIDE_RIGHT)
xoffsetDyn = screenwidth;
}
if(eff & EFFECT_FADE && amount > 0)
{
alphaDyn = 0;
}
else if(eff & EFFECT_FADE && amount < 0)
{
alphaDyn = alpha;
} else if(eff & EFFECT_ROCK_VERTICLE) {
changervar = 0;
yoffsetDyn = 0;
yoffsetDynFloat = 0.0;
}
effects |= eff;
effectAmount = amount;
effectTarget = target;
}
void GuiElement::SetEffectOnOver(int eff, int amount, int target)
{
LOCK(this);
effectsOver |= eff;
effectAmountOver = amount;
effectTargetOver = target;
}
void GuiElement::SetEffectGrow()
{
SetEffectOnOver(EFFECT_SCALE, 4, 110);
}
void GuiElement::StopEffect()
{
xoffsetDyn = 0;
yoffsetDyn = 0;
effects = 0;
effectsOver = 0;
effectAmount = 0;
effectAmountOver = 0;
effectTarget = 0;
effectTargetOver = 0;
scaleDyn = 1;
frequency = 0.0f;
changervar = 0;
//angleDyn = 0.0f;
anglespeed = 0.0f;
}
void GuiElement::UpdateEffects()
{
LOCK(this);
if(effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_GOROUND))
{
if(effects & EFFECT_SLIDE_IN)
{
if(effects & EFFECT_SLIDE_LEFT)
{
xoffsetDyn += effectAmount;
if(xoffsetDyn >= 0)
{
xoffsetDyn = 0;
effects = 0;
}
}
else if(effects & EFFECT_SLIDE_RIGHT)
{
xoffsetDyn -= effectAmount;
if(xoffsetDyn <= 0)
{
xoffsetDyn = 0;
effects = 0;
}
}
else if(effects & EFFECT_SLIDE_TOP)
{
yoffsetDyn += effectAmount;
if(yoffsetDyn >= 0)
{
yoffsetDyn = 0;
effects = 0;
}
}
else if(effects & EFFECT_SLIDE_BOTTOM)
{
yoffsetDyn -= effectAmount;
if(yoffsetDyn <= 0)
{
yoffsetDyn = 0;
effects = 0;
}
}
}
else
{
if(effects & EFFECT_SLIDE_LEFT)
{
xoffsetDyn -= effectAmount;
if(xoffsetDyn <= -screenwidth)
effects = 0; // shut off effect
}
else if(effects & EFFECT_SLIDE_RIGHT)
{
xoffsetDyn += effectAmount;
if(xoffsetDyn >= screenwidth)
effects = 0; // shut off effect
}
else if(effects & EFFECT_SLIDE_TOP)
{
yoffsetDyn -= effectAmount;
if(yoffsetDyn <= -screenheight)
effects = 0; // shut off effect
}
else if(effects & EFFECT_SLIDE_BOTTOM)
{
yoffsetDyn += effectAmount;
if(yoffsetDyn >= screenheight)
effects = 0; // shut off effect
}
}
}
if(effects & EFFECT_GOROUND) {
//!< check out gui.h for info
xoffset = temp_xoffset;
yoffset = temp_yoffset;
if(fabs(frequency) < circleamount) {
angleDyn = (frequency+degree+90.0f) * anglespeed;
xoffsetDyn = (int) lround(((f32) Radius)*cos((frequency+degree)*PI/180.0f));
yoffsetDyn = (int) lround(((f32) Radius)*sin((frequency+degree)*PI/180.0f));
frequency += ((f32) effectAmount)*0.01f;
} else {
f32 temp_frequency = ((effectAmount<0)?-1.0f:1.0f)*circleamount;
angleDyn = (temp_frequency+degree+90.0f) * anglespeed;
xoffsetDyn = (int) lround(((f32) Radius)*cos((temp_frequency+degree)*PI/180.0f));
yoffsetDyn = (int) lround(((f32) Radius)*sin((temp_frequency+degree)*PI/180.0f));
xoffset += xoffsetDyn;
yoffset += yoffsetDyn;
effects ^= EFFECT_GOROUND;
frequency = 0.0f;
}
}
if(effects & EFFECT_ROCK_VERTICLE) {
//move up to 10pixel above 0
if(changervar == 0 && yoffsetDynFloat < 11.0) {
yoffsetDynFloat += (effectAmount*0.01);
} else if(yoffsetDynFloat > 10.0) {
changervar = 1;
}
//move down till 10pixel under 0
if(changervar == 1 && yoffsetDynFloat > -11.0) {
yoffsetDynFloat -= (effectAmount*0.01);
} else if(yoffsetDynFloat < -10.0) {
changervar = 0;
}
yoffsetDyn = (int)(yoffsetDynFloat);
}
if(effects & EFFECT_FADE)
{
alphaDyn += effectAmount;
if(effectAmount < 0 && alphaDyn <= 0)
{
alphaDyn = 0;
effects = 0; // shut off effect
}
else if(effectAmount > 0 && alphaDyn >= alpha)
{
alphaDyn = alpha;
effects = 0; // shut off effect
}
}
if(effects & EFFECT_SCALE)
{
scaleDyn += effectAmount/100.0;
if((effectAmount < 0 && scaleDyn <= effectTarget/100.0)
|| (effectAmount > 0 && scaleDyn >= effectTarget/100.0))
{
scaleDyn = effectTarget/100.0;
effects = 0; // shut off effect
}
}
if(effects & EFFECT_PULSE)
{
int percent = 10; //go down from target by this
if((scaleDyn <= (effectTarget*0.01)) && (!changervar)) {
scaleDyn += (effectAmount*0.001);
} else if(scaleDyn > (effectTarget*0.01)) {
changervar = 1;
}
if((scaleDyn >= ((effectTarget-percent)*0.01)) && (changervar)) {
scaleDyn -= (effectAmount*0.001);
} else if(scaleDyn < ((effectTarget-percent)*0.01)) {
changervar = 0;
}
}
}
void GuiElement::Update(GuiTrigger * t)
{
LOCK(this);
if(updateCB)
updateCB(this);
}
void GuiElement::SetUpdateCallback(UpdateCallback u)
{
LOCK(this);
updateCB = u;
}
void GuiElement::SetPosition(int xoff, int yoff, int zoff)
{
LOCK(this);
xoffset = xoff;
yoffset = yoff;
zoffset = zoff;
}
void GuiElement::SetAlignment(int hor, int vert)
{
LOCK(this);
alignmentHor = hor;
alignmentVert = vert;
}
int GuiElement::GetSelected()
{
return -1;
}
/**
* Draw an element on screen.
*/
void GuiElement::Draw()
{
}
/**
* Draw Tooltips on screen.
*/
void GuiElement::DrawTooltip()
{
}
/**
* Check if a position is inside the GuiElement.
* @param[in] x X position in pixel.
* @param[in] y Y position in pixel.
*/
bool GuiElement::IsInside(int x, int y)
{
if(x > this->GetLeft() && x < (this->GetLeft()+width)
&& y > this->GetTop() && y < (this->GetTop()+height))
return true;
return false;
}
void GuiElement::Lock()
{
LWP_MutexLock(mutex);
}
void GuiElement::Unlock()
{
LWP_MutexUnlock(mutex);
}
SimpleLock::SimpleLock(GuiElement *e) : element(e)
{
element->Lock();
}
SimpleLock::~SimpleLock()
{
element->Unlock();
}