usbloadergx/source/prompts/ProgressWindow.cpp

/****************************************************************************
 * ProgressWindow
 * USB Loader GX 2009
 *
 * ProgressWindow.cpp
 ***************************************************************************/
#include <gccore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "menu/menus.h"
#include "sys.h"
#include "language/gettext.h"
#include "GUI/gui.h"
#include "prompts/ProgressWindow.h"
#include "usbloader/wbfs.h"
#include "usbloader/utils.h"
#include "themes/CTheme.h"
#include "utils/timer.h"

/*** Variables used only in this file ***/
static lwp_t progressthread = LWP_THREAD_NULL;
static mutex_t ProgressMutex = LWP_MUTEX_NULL;
static ProgressAbortCallback AbortCallback = NULL;
static const char * progressTitle = NULL;
static const char * progressMsg1 = NULL;
static const char * progressMsg2 = NULL;
static Timer ProgressTimer;
static int showProgress = 0;
static s64 progressDone = -1;
static s64 progressTotal = -1;
static bool showTime = false;
static bool showSize = false;
static bool changed = true;
static bool changedMessages = true;

/****************************************************************************
 * StartProgress
 ***************************************************************************/
extern "C" void StartProgress(const char * title, const char * msg1, const char * msg2, bool swSize, bool swTime)
{
	progressTitle = title;
	progressMsg1 = msg1;
	progressMsg2 = msg2;
	showSize = swSize;
	showTime = swTime;
	showProgress = 1;
	ProgressTimer.reset();

	LWP_ResumeThread(progressthread);
}

/****************************************************************************
 * ShowProgress
 *
 * Callbackfunction for updating the progress values
 * Use this function as standard callback
 ***************************************************************************/
extern "C" void ShowProgress(s64 done, s64 total)
{
	LWP_MutexLock(ProgressMutex);
	progressDone = done;
	progressTotal = total;
	if(!done)
	{
		ProgressTimer.reset();
		LWP_ResumeThread(progressthread);
		showProgress = 1;
	}
	changed = true;
	LWP_MutexUnlock(ProgressMutex);
}

void ShowProgress(const char *title, const char *msg1, const char *msg2, s64 done, s64 total, bool swSize, bool swTime)
{
	if (total <= 0)
		return;

	else if (done > total)
		done = total;

	LWP_MutexLock(ProgressMutex);

	progressDone = done;
	progressTotal = total;

	progressTitle = title;
	progressMsg1 = msg1;
	progressMsg2 = msg2;

	showSize = swSize;
	showTime = swTime;

	if(!done)
	{
		ProgressTimer.reset();
		LWP_ResumeThread(progressthread);
		showProgress = 1;
	}

	changedMessages = true;
	changed = true;

	LWP_MutexUnlock(ProgressMutex);
}

/****************************************************************************
 * ProgressStop
 ***************************************************************************/
extern "C" void ProgressStop()
{
	showProgress = 0;
	progressTitle = NULL;
	progressMsg1 = NULL;
	progressMsg2 = NULL;
	progressDone = -1;
	progressTotal = -1;
	showTime = false;
	showSize = false;

	// wait for thread to finish
	while (!LWP_ThreadIsSuspended(progressthread))
		usleep(100);
}

/****************************************************************************
 * ProgressSetAbortCallback
 *
 * Set a callback for the cancel button
 ***************************************************************************/
extern "C" void ProgressSetAbortCallback(ProgressAbortCallback callback)
{
	AbortCallback = callback;
}

/****************************************************************************
 * UpdateProgressValues
 ***************************************************************************/
static void UpdateProgressValues(GuiImage *progressbarImg, GuiText *prTxt, GuiText *timeTxt, GuiText *speedTxt, GuiText *sizeTxt)
{
	if(!changed)
		return;

	extern u64 gamesize;

	LWP_MutexLock(ProgressMutex);
	changed = false;
	changedMessages = false;
	s64 done = progressDone;
	s64 total = progressTotal;
	u32 speed = 0;

	if(gamesize > 0)
	{
		done = (s64) ((double) done / (double) total * (double) gamesize);
		total = (s64) gamesize;
	}

	//Calculate speed in KB/s
	if (ProgressTimer.elapsed() > 0.0f)
		speed = (u32) (done/ProgressTimer.elapsed());

	LWP_MutexUnlock(ProgressMutex);

	u32 TimeLeft = 0, h = 0, m = 0, s = 0;
	if(speed > 0)
		TimeLeft = (total-done)/speed;

	if(TimeLeft > 0)
	{
		h =  TimeLeft / 3600;
		m = (TimeLeft / 60) % 60;
		s =  TimeLeft % 60;
	}

	float progressPercent = 100.0 * done / total;

	prTxt->SetTextf("%.2f", progressPercent);

	if (Settings.widescreen && Settings.wsprompt)
		progressbarImg->SetSkew(0, 0, static_cast<int> (progressbarImg->GetWidth() * progressPercent * Settings.WSFactor)
				- progressbarImg->GetWidth(), 0, static_cast<int> (progressbarImg->GetWidth() * progressPercent
				* Settings.WSFactor) - progressbarImg->GetWidth(), 0, 0, 0);
	else
		progressbarImg->SetSkew(0, 0, static_cast<int> (progressbarImg->GetWidth() * progressPercent)
			- progressbarImg->GetWidth(), 0, static_cast<int> (progressbarImg->GetWidth() * progressPercent)
			- progressbarImg->GetWidth(), 0, 0, 0);

	if (showTime == true)
	{
		timeTxt->SetTextf("%s %d:%02d:%02d", tr( "Time left:" ), h, m, s);
	}

	if (showSize == true)
	{
		if (total < MB_SIZE)
			sizeTxt->SetTextf("%0.2fKB/%0.2fKB", done / KB_SIZE, total / KB_SIZE);
		else if (total > MB_SIZE && total < GB_SIZE)
			sizeTxt->SetTextf("%0.2fMB/%0.2fMB", done / MB_SIZE, total / MB_SIZE);
		else
			sizeTxt->SetTextf("%0.2fGB/%0.2fGB", done / GB_SIZE, total / GB_SIZE);

		speedTxt->SetTextf("%dKB/s", (int) (speed/KB_SIZE));
	}
}

/****************************************************************************
 * ProgressWindow
 *
 * Opens a window, which displays progress to the user. Can either display a
 * progress bar showing % completion, or a throbber that only shows that an
 * action is in progress.
 ***************************************************************************/
static void ProgressWindow(const char *title, const char *msg1, const char *msg2)
{
	GuiWindow promptWindow(472, 320);
	promptWindow.SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
	promptWindow.SetPosition(0, -10);

	GuiImageData btnOutline(Resources::GetFile("button_dialogue_box.png"), Resources::GetFileSize("button_dialogue_box.png"));
	GuiImageData dialogBox(Resources::GetFile("dialogue_box.png"), Resources::GetFileSize("dialogue_box.png"));

	GuiTrigger trigA;
	trigA.SetSimpleTrigger(-1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A);

	GuiImage dialogBoxImg(&dialogBox);
	if (Settings.wsprompt)
	{
		dialogBoxImg.SetWidescreen(Settings.widescreen);
	}

	GuiImageData progressbarOutline(Resources::GetFile("progressbar_outline.png"), Resources::GetFileSize("progressbar_outline.png"));

	GuiImage progressbarOutlineImg(&progressbarOutline);
	if (Settings.wsprompt)
	{
		progressbarOutlineImg.SetWidescreen(Settings.widescreen);
	}
	progressbarOutlineImg.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
	progressbarOutlineImg.SetPosition(35, 40);

	GuiImageData progressbarEmpty(Resources::GetFile("progressbar_empty.png"), Resources::GetFileSize("button_dialogue_box.png"));
	GuiImage progressbarEmptyImg(&progressbarEmpty);
	progressbarEmptyImg.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
	progressbarEmptyImg.SetPosition(35, 40);
	progressbarEmptyImg.SetTileHorizontal(100);

	GuiImageData progressbar(Resources::GetFile("progressbar.png"), Resources::GetFileSize("progressbar.png"));
	GuiImage progressbarImg(&progressbar);
	progressbarImg.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
	progressbarImg.SetPosition(35, 40);

	GuiText titleTxt(title, 26, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	titleTxt.SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
	titleTxt.SetPosition(0, 60);

	GuiText msg1Txt(msg1, 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	msg1Txt.SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
	if (msg2)
		msg1Txt.SetPosition(0, 100);
	else
		msg1Txt.SetPosition(0, 120);
	msg1Txt.SetMaxWidth(430, DOTTED);

	GuiText msg2Txt(msg2, 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	msg2Txt.SetAlignment(ALIGN_CENTRE, ALIGN_TOP);
	msg2Txt.SetPosition(0, 125);
	msg2Txt.SetMaxWidth(430, DOTTED);

	GuiText prsTxt("%", 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	prsTxt.SetAlignment(ALIGN_RIGHT, ALIGN_MIDDLE);
	prsTxt.SetPosition(-178, 40);

	GuiText timeTxt((char*) NULL, 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	timeTxt.SetAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
	timeTxt.SetPosition(280, -50);

	GuiText sizeTxt((char*) NULL, 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	sizeTxt.SetAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
	sizeTxt.SetPosition(50, -50);

	GuiText speedTxt((char*) NULL, 22, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	speedTxt.SetAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
	speedTxt.SetPosition(50, -74);

	GuiText prTxt((char*) NULL, 26, thColor("r=0 g=0 b=0 a=255 - prompt windows text color"));
	prTxt.SetAlignment(ALIGN_LEFT, ALIGN_MIDDLE);
	prTxt.SetPosition(210, 40);

	if ((Settings.wsprompt) && (Settings.widescreen)) /////////////adjust for widescreen
	{
		progressbarOutlineImg.SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
		progressbarOutlineImg.SetPosition(0, 40);
		progressbarEmptyImg.SetPosition(80, 40);
		progressbarEmptyImg.SetTileHorizontal(78);
		progressbarImg.SetPosition(80, 40);
		msg1Txt.SetMaxWidth(380, DOTTED);
		msg2Txt.SetMaxWidth(380, DOTTED);

		timeTxt.SetPosition(250, -50);
		timeTxt.SetFontSize(20);
		speedTxt.SetPosition(90, -74);
		speedTxt.SetFontSize(20);
		sizeTxt.SetPosition(90, -50);
		sizeTxt.SetFontSize(20);
	}

	GuiText cancelTxt(tr( "Cancel" ), 22, thColor("r=0 g=0 b=0 a=255 - prompt windows button text color"));
	GuiImage cancelImg(&btnOutline);
	if (Settings.wsprompt)
	{
		cancelTxt.SetWidescreen(Settings.widescreen);
		cancelImg.SetWidescreen(Settings.widescreen);
	}
	GuiButton cancelBtn(&cancelImg, &cancelImg, 2, 4, 0, -45, &trigA, btnSoundOver, btnSoundClick2, 1);
	cancelBtn.SetLabel(&cancelTxt);
	cancelBtn.SetState(STATE_SELECTED);

	usleep(400000); // wait to see if progress flag changes soon
	if (!showProgress) return;

	promptWindow.Append(&dialogBoxImg);
	promptWindow.Append(&progressbarEmptyImg);
	promptWindow.Append(&progressbarImg);
	promptWindow.Append(&progressbarOutlineImg);
	promptWindow.Append(&prTxt);
	promptWindow.Append(&prsTxt);
	if (title) promptWindow.Append(&titleTxt);
	promptWindow.Append(&msg1Txt);
	promptWindow.Append(&msg2Txt);
	if (showTime) promptWindow.Append(&timeTxt);
	if (showSize)
	{
		promptWindow.Append(&sizeTxt);
		promptWindow.Append(&speedTxt);
	}
	if(AbortCallback)
		promptWindow.Append(&cancelBtn);

	HaltGui();
	promptWindow.SetEffect(EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50);
	mainWindow->SetState(STATE_DISABLED);
	mainWindow->Append(&promptWindow);
	mainWindow->ChangeFocus(&promptWindow);
	ResumeGui();

	while (promptWindow.GetEffect() > 0) usleep(100);

	while (showProgress)
	{
		usleep(50000);

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

		if (changed)
		{
			if (changedMessages && progressTitle) titleTxt.SetText(progressTitle);
			if (changedMessages && progressMsg1) msg1Txt.SetText(progressMsg1);
			if (changedMessages && progressMsg2) msg2Txt.SetText(progressMsg2);

			UpdateProgressValues(&progressbarImg, &prTxt, &timeTxt, &speedTxt, &sizeTxt);
		}

		if(cancelBtn.GetState() == STATE_CLICKED)
		{
			if(AbortCallback) AbortCallback();
			cancelBtn.ResetState();
		}
	}

	promptWindow.SetEffect(EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50);
	while (promptWindow.GetEffect() > 0) usleep(100);

	HaltGui();
	mainWindow->Remove(&promptWindow);
	mainWindow->SetState(STATE_DEFAULT);
	ResumeGui();
}

/****************************************************************************
 * ProgressThread
 ***************************************************************************/
static void * ProgressThread(void *arg)
{
	while (1)
	{
		if (!showProgress) LWP_SuspendThread(progressthread);

		ProgressWindow(progressTitle, progressMsg1, progressMsg2);
		usleep(100);
	}
	return NULL;
}

/****************************************************************************
 * InitProgressThread
 *
 * Startup Progressthread in idle prio
 ***************************************************************************/
void InitProgressThread()
{
	LWP_MutexInit(&ProgressMutex, true);
	LWP_CreateThread(&progressthread, ProgressThread, NULL, NULL, 16384, 70);
}

/****************************************************************************
 * ExitProgressThread
 *
 * Shutdown Progressthread
 ***************************************************************************/
void ExitProgressThread()
{
	LWP_JoinThread(progressthread, NULL);
	progressthread = LWP_THREAD_NULL;
	LWP_MutexUnlock(ProgressMutex);
	LWP_MutexDestroy(ProgressMutex);
}