usbloadergx/source/settings/menus/FlyingButtonsMenu.cpp

/****************************************************************************
 * Copyright (C) 2010
 * by Dimok
 *
 * 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.
 ***************************************************************************/
#include <string.h>
#include <unistd.h>

#include "FlyingButtonsMenu.hpp"
#include "utils/StringTools.h"
#include "language/gettext.h"
#include "themes/CTheme.h"
#include "menu/menus.h"
#include "sys.h"

#define FADE_SPEED 20
#define SLIDE_SPEED 35
#define DISPLAY_BUTTONS	4
#define MAX_INDICATORS	 5

FlyingButtonsMenu::FlyingButtonsMenu(const char * menu_title)
	:   GuiWindow(screenwidth, screenheight)

{
	currentPage = 0;
	returnMenu = MENU_NONE;
	ParentMenu = MENU_DISCLIST;
	CurrentMenu = NULL;
	titleTxt = NULL;
	GoLeftImg = NULL;
	GoLeftBtn = NULL;
	GoRightImg = NULL;
	GoRightBtn = NULL;
	MenuTitle = menu_title ? menu_title : " ";

	trigA = new GuiTrigger();
	trigHome = new GuiTrigger();
	trigB = new GuiTrigger();
	trigL = new GuiTrigger();
	trigR = new GuiTrigger();
	trigMinus = new GuiTrigger();
	trigPlus = new GuiTrigger();
	trigA->SetSimpleTrigger(-1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A);
	trigHome->SetButtonOnlyTrigger(-1, WPAD_BUTTON_HOME | WPAD_CLASSIC_BUTTON_HOME, 0);
	trigB->SetButtonOnlyTrigger(-1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B);
	trigL->SetButtonOnlyTrigger(-1, WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT, PAD_BUTTON_LEFT);
	trigR->SetButtonOnlyTrigger(-1, WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT, PAD_BUTTON_RIGHT);
	trigMinus->SetButtonOnlyTrigger(-1, WPAD_BUTTON_MINUS | WPAD_CLASSIC_BUTTON_MINUS, 0);
	trigPlus->SetButtonOnlyTrigger(-1, WPAD_BUTTON_PLUS | WPAD_CLASSIC_BUTTON_PLUS, 0);

	btnOutline = Resources::GetImageData("button_dialogue_box.png");
	settingsbg = Resources::GetImageData("settings_background.png");
	MainButtonImgData = Resources::GetImageData("settings_title.png");
	MainButtonImgOverData = Resources::GetImageData("settings_title_over.png");
	PageindicatorImgData = Resources::GetImageData("pageindicator.png");
	arrow_left = Resources::GetImageData("startgame_arrow_left.png");
	arrow_right = Resources::GetImageData("startgame_arrow_right.png");

	settingsbackground = new GuiImage(settingsbg);
	Append(settingsbackground);

	homeBtn = new GuiButton(1, 1);
	homeBtn->SetTrigger(trigHome);
	Append(homeBtn);

	backBtnTxt = new GuiText(tr( "Back" ), 22, thColor("r=0 g=0 b=0 a=255 - prompt windows button text color"));
	backBtnTxt->SetMaxWidth(btnOutline->GetWidth() - 30);
	backBtnImg = new GuiImage(btnOutline);
	if (Settings.wsprompt == ON)
	{
		backBtnTxt->SetWidescreen(Settings.widescreen);
		backBtnImg->SetWidescreen(Settings.widescreen);
	}
	backBtn = new GuiButton(backBtnImg, backBtnImg, 2, 3, -195, 400, trigA, btnSoundOver, btnSoundClick2, 1);
	backBtn->SetLabel(backBtnTxt);
	backBtn->SetTrigger(trigB);
	Append(backBtn);

	SetEffect(EFFECT_FADE, FADE_SPEED);
}

FlyingButtonsMenu::~FlyingButtonsMenu()
{
	ResumeGui();

	SetEffect(EFFECT_FADE, -FADE_SPEED);
	while(parentElement && this->GetEffect() > 0) usleep(100);

	HaltGui();
	if(parentElement)
		((GuiWindow *) parentElement)->Remove(this);

	RemoveAll();
	HideMenu();

	delete trigA;
	delete trigHome;
	delete trigB;
	delete trigL;
	delete trigR;
	delete trigMinus;
	delete trigPlus;
	delete settingsbackground;
	delete homeBtn;
	delete btnOutline;
	delete settingsbg;
	delete MainButtonImgData;
	delete MainButtonImgOverData;
	delete PageindicatorImgData;
	delete arrow_left;
	delete arrow_right;
	delete backBtnTxt;
	delete backBtnImg;
	delete backBtn;

	ResumeGui();
}

void FlyingButtonsMenu::SetPageIndicators()
{
	HaltGui();

	for(u32 i = 0; i < PageIndicatorBtn.size(); ++i)
	{
		Remove(PageIndicatorBtn[i]);
		delete PageindicatorImg[i];
		delete PageindicatorTxt[i];
		delete PageIndicatorBtn[i];
	}
	PageindicatorImg.clear();
	PageindicatorTxt.clear();
	PageIndicatorBtn.clear();

	int IndicatorCount = ceil(MainButton.size()/(1.0f*DISPLAY_BUTTONS));

	FirstIndicator = 0;
	if(currentPage > (int) floor(MAX_INDICATORS/2.0f))
	{
		if(IndicatorCount-MAX_INDICATORS < currentPage - (int) floor(MAX_INDICATORS/2.0f))
			FirstIndicator = IndicatorCount-MAX_INDICATORS;
		else
			FirstIndicator = currentPage - (int) floor(MAX_INDICATORS/2.0f);

		if(FirstIndicator < 0)
			FirstIndicator = 0;
	}

	int DisplayedIndicators = IndicatorCount > MAX_INDICATORS ? MAX_INDICATORS : IndicatorCount;

	for(int i = 0, n = FirstIndicator; i < MAX_INDICATORS && n < IndicatorCount; ++i, ++n)
	{
		PageindicatorImg.push_back(new GuiImage(PageindicatorImgData));
		PageindicatorTxt.push_back(new GuiText(fmt("%i", n+1), 22, ( GXColor ) {0, 0, 0, 255}));
		PageIndicatorBtn.push_back(new GuiButton(PageindicatorImgData->GetWidth(), PageindicatorImgData->GetHeight()));
		PageIndicatorBtn[i]->SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
		PageIndicatorBtn[i]->SetPosition(270-DisplayedIndicators*35+35*i, 400);
		PageIndicatorBtn[i]->SetImage(PageindicatorImg[i]);
		PageIndicatorBtn[i]->SetLabel(PageindicatorTxt[i]);
		PageIndicatorBtn[i]->SetSoundOver(btnSoundOver);
		PageIndicatorBtn[i]->SetSoundClick(btnSoundClick);
		PageIndicatorBtn[i]->SetTrigger(trigA);
		PageIndicatorBtn[i]->SetEffectGrow();
		PageIndicatorBtn[i]->SetAlpha(n == currentPage ? 255 : 50);
		Append(PageIndicatorBtn[i]);
	}
}

void FlyingButtonsMenu::SetMainButton(int position, const char * ButtonText, GuiImageData * imageData, GuiImageData * imageOver)
{
	//! Don't allow operating gui mode while adding/setting the buttons
	HaltGui();

	if(position < (int) MainButton.size())
	{
		delete MainButtonImg[position];
		delete MainButtonImgOver[position];
		delete MainButtonTxt[position];
		delete MainButton[position];
	}
	else
	{
		MainButtonImg.resize(position+1);
		MainButtonImgOver.resize(position+1);
		MainButtonTxt.resize(position+1);
		MainButton.resize(position+1);
	}

	MainButtonImg[position] = new GuiImage(imageData);
	MainButtonImgOver[position] = new GuiImage(imageOver);

	MainButtonTxt[position] = new GuiText(ButtonText, 22, ( GXColor ) {0, 0, 0, 255});
	MainButtonTxt[position]->SetMaxWidth(MainButtonImg[position]->GetWidth());

	MainButton[position] = new GuiButton(imageData->GetWidth(), imageData->GetHeight());
	MainButton[position]->SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
	MainButton[position]->SetPosition(0, 90+(position % DISPLAY_BUTTONS)*70);
	MainButton[position]->SetImage(MainButtonImg[position]);
	MainButton[position]->SetImageOver(MainButtonImgOver[position]);
	MainButton[position]->SetLabel(MainButtonTxt[position]);
	MainButton[position]->SetSoundOver(btnSoundOver);
	MainButton[position]->SetSoundClick(btnSoundClick);
	MainButton[position]->SetEffectGrow();
	MainButton[position]->SetTrigger(trigA);
}

void FlyingButtonsMenu::HideMenu()
{
	HaltGui();

	if(titleTxt)
		Remove(titleTxt);
	if(GoLeftBtn)
		Remove(GoLeftBtn);
	if(GoRightBtn)
		Remove(GoRightBtn);

	if(titleTxt)
		delete titleTxt;
	if(GoLeftImg)
		delete GoLeftImg;
	if(GoLeftBtn)
		delete GoLeftBtn;
	if(GoRightImg)
		delete GoRightImg;
	if(GoRightBtn)
		delete GoRightBtn;
	titleTxt = NULL;
	GoLeftImg = NULL;
	GoLeftBtn = NULL;
	GoRightImg = NULL;
	GoRightBtn = NULL;

	for(u32 i = 0; i < MainButton.size(); ++i)
	{
		Remove(MainButton[i]);
		delete MainButtonImg[i];
		delete MainButtonImgOver[i];
		delete MainButtonTxt[i];
		delete MainButton[i];
	}
	for(u32 i = 0; i < PageIndicatorBtn.size(); ++i)
	{
		Remove(PageIndicatorBtn[i]);
		delete PageindicatorImg[i];
		delete PageindicatorTxt[i];
		delete PageIndicatorBtn[i];
	}

	PageindicatorImg.clear();
	PageindicatorTxt.clear();
	PageIndicatorBtn.clear();
	MainButtonImg.clear();
	MainButtonImgOver.clear();
	MainButtonTxt.clear();
	MainButton.clear();
}

void FlyingButtonsMenu::ShowMenu()
{
	//! Free memory if not done yet because new is allocated
	HideMenu();

	titleTxt = new GuiText(MenuTitle.c_str(), 28, ( GXColor ) {0, 0, 0, 255});
	titleTxt->SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
	titleTxt->SetPosition(0, 40);
	titleTxt->SetMaxWidth(310, SCROLL_HORIZONTAL);
	Append(titleTxt);

	GoLeftImg = new GuiImage(arrow_left);
	GoLeftBtn = new GuiButton(GoLeftImg->GetWidth(), GoLeftImg->GetHeight());
	GoLeftBtn->SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
	GoLeftBtn->SetPosition(25, -25);
	GoLeftBtn->SetImage(GoLeftImg);
	GoLeftBtn->SetSoundOver(btnSoundOver);
	GoLeftBtn->SetSoundClick(btnSoundClick2);
	GoLeftBtn->SetEffectGrow();
	GoLeftBtn->SetTrigger(trigA);
	GoLeftBtn->SetTrigger(trigL);
	GoLeftBtn->SetTrigger(trigMinus);
	Append(GoLeftBtn);

	GoRightImg = new GuiImage(arrow_right);
	GoRightBtn = new GuiButton(GoRightImg->GetWidth(), GoRightImg->GetHeight());
	GoRightBtn->SetAlignment(ALIGN_RIGHT, ALIGN_MIDDLE);
	GoRightBtn->SetPosition(-25, -25);
	GoRightBtn->SetImage(GoRightImg);
	GoRightBtn->SetSoundOver(btnSoundOver);
	GoRightBtn->SetSoundClick(btnSoundClick2);
	GoRightBtn->SetEffectGrow();
	GoRightBtn->SetTrigger(trigA);
	GoRightBtn->SetTrigger(trigR);
	GoRightBtn->SetTrigger(trigPlus);
	Append(GoRightBtn);

	SetupMainButtons();
	AddMainButtons();

	ShowButtonsEffects(EFFECT_FADE, FADE_SPEED);
}

void FlyingButtonsMenu::AddMainButtons()
{
	HaltGui();

	for(u32 i = 0; i < MainButton.size(); ++i)
		Remove(MainButton[i]);

	int FirstItem = currentPage*DISPLAY_BUTTONS;

	for(int i = FirstItem; i < (int) MainButton.size() && i < FirstItem+DISPLAY_BUTTONS; ++i)
	{
		Append(MainButton[i]);
	}

	SetPageIndicators();
}

void FlyingButtonsMenu::ShowButtonsEffects(int effect, int effect_speed)
{
	int FirstItem = currentPage*DISPLAY_BUTTONS;
	if(FirstItem < 0)
		FirstItem = 0;

	HaltGui();

	for(int i = FirstItem; i < (int) MainButton.size() && i < FirstItem+DISPLAY_BUTTONS; ++i)
	{
		MainButton[i]->StopEffect();
		MainButton[i]->SetEffectGrow();
		MainButton[i]->SetEffect(effect, effect_speed);
	}

	ResumeGui();

	if(FirstItem < 0 || FirstItem >= (int) MainButton.size())
		return;

	//! Don't lock on fade in for initiation purpose
	if((effect & EFFECT_FADE) && effect_speed > 0)
		return;

	while (parentElement && MainButton[FirstItem]->GetEffect() > 0)
		usleep(100);
}

void FlyingButtonsMenu::SlideButtons(int direction)
{
	int SlideEffectIN = 0;

	if(direction == SLIDE_LEFT)
	{
		ShowButtonsEffects(EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, SLIDE_SPEED);
		SlideEffectIN = EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN;

		currentPage--;

		if(currentPage < 0)
			currentPage = MainButton.size() > 0 ? ceil(MainButton.size()/4.0f)-1 : 0;
	}
	else
	{
		ShowButtonsEffects(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, SLIDE_SPEED);
		SlideEffectIN = EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_IN;

		currentPage++;

		if(currentPage >= ceil(MainButton.size()/4.0f))
			currentPage = 0;
	}

	AddMainButtons();

	ShowButtonsEffects(SlideEffectIN, SLIDE_SPEED);
}

int FlyingButtonsMenu::MainLoop()
{
	usleep(100);

	if(shutdown)
		Sys_Shutdown();
	else if(reset)
		Sys_Reboot();

	if(backBtn->GetState() == STATE_CLICKED)
	{
		if(CurrentMenu)
		{
			DeleteSettingsMenu();
			ShowMenu();
		}
		else
		{
			return ParentMenu;
		}
		backBtn->ResetState();
	}
	else if(GoRightBtn && GoRightBtn->GetState() == STATE_CLICKED)
	{
		SlideButtons(SLIDE_RIGHT);
		GoRightBtn->ResetState();
	}
	else if(GoLeftBtn && GoLeftBtn->GetState() == STATE_CLICKED)
	{
		SlideButtons(SLIDE_LEFT);
		GoLeftBtn->ResetState();
	}
	else if(homeBtn->GetState() == STATE_CLICKED)
	{
		Settings.Save();
		if(CurrentMenu) CurrentMenu->SetState(STATE_DISABLED);
		WindowExitPrompt();
		homeBtn->ResetState();
		if(CurrentMenu) CurrentMenu->SetState(STATE_DEFAULT);
	}
	else if(CurrentMenu)
	{
		int newMenu = CurrentMenu->GetMenu();
		if(newMenu != MENU_NONE)
			return newMenu;
	}

	for(u32 i = 0; i < PageIndicatorBtn.size(); ++i)
	{
		if(PageIndicatorBtn[i]->GetState() != STATE_CLICKED)
			continue;

		if(FirstIndicator+i < (u32) currentPage)
		{
			ShowButtonsEffects(EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, SLIDE_SPEED);
			currentPage = FirstIndicator+i;
			AddMainButtons();
			ShowButtonsEffects(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN, SLIDE_SPEED);
		}
		else if(FirstIndicator+i > (u32) currentPage)
		{
			ShowButtonsEffects(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, SLIDE_SPEED);
			currentPage = FirstIndicator+i;
			AddMainButtons();
			ShowButtonsEffects(EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_IN, SLIDE_SPEED);
		}

		PageIndicatorBtn[i]->ResetState();
	}

	for(u32 i = 0; i < MainButton.size(); ++i)
	{
		if(MainButton[i]->GetState() != STATE_CLICKED)
			continue;

		MainButton[i]->ResetState();

		CreateSettingsMenu(i);
		break;
	}

	return returnMenu;
}