ash/Anemone3DS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4d9cde01c4bfde4321c774d4549bd29f5a93be43
Anemone3DS/source/main.c
Alex Taber 4d9cde01c4 Initial badges work 
Additional cleanup probably necessary, some more feature work still in progress (zip files)
2024-05-30 15:45:57 -04:00

1119 lines
36 KiB
C
Raw Blame History

/*
* This file is part of Anemone3DS
* Copyright (C) 2015-2020 Contributors in CONTRIBUTORS.md
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Additional Terms 7.b and 7.c of GPLv3 apply to this file:
* * Requiring preservation of specified reasonable legal notices or
* author attributions in that material or in the Appropriate Legal
* Notices displayed by works containing it.
* * Prohibiting misrepresentation of the origin of that material,
* or requiring that modified versions of such material be marked in
* reasonable ways as different from the original version.
*/
#include "fs.h"
#include "loading.h"
#include "themes.h"
#include "splashes.h"
#include "draw.h"
#include "camera.h"
#include "music.h"
#include "remote.h"
#include "ui_strings.h"
#include "badges.h"
#include <time.h>
bool quit = false;
bool dspfirm = false;
static audio_s * audio = NULL;
static bool homebrew = false;
static bool installed_themes = false;
bool home_displayed = false;
u64 time_home_pressed = 0;
static Thread iconLoadingThread = {0};
static Thread_Arg_s iconLoadingThread_arg = {0};
static Handle update_icons_mutex;
static bool released = false;
static Thread install_check_threads[MODE_AMOUNT] = {0};
static Thread_Arg_s install_check_threads_arg[MODE_AMOUNT] = {0};
static Entry_List_s lists[MODE_AMOUNT] = {0};
Language_s language = {0};
int __stacksize__ = 64 * 1024;
Result archive_result;
u32 old_time_limit;
const char * main_paths[MODE_AMOUNT] = {
"/Themes/",
"/Splashes/",
};
const int entries_per_screen_v[MODE_AMOUNT] = {
4,
4,
};
const int entries_per_screen_h[MODE_AMOUNT] = { //for themeplaza browser
6,
6,
};
const int entry_size[MODE_AMOUNT] = {
48,
48,
};
static void init_services(void)
{
consoleDebugInit(debugDevice_SVC);
cfguInit();
ptmuInit();
acInit();
dspfirm = !ndspInit();
APT_GetAppCpuTimeLimit(&old_time_limit);
APT_SetAppCpuTimeLimit(30);
httpcInit(0);
archive_result = open_archives();
if(envIsHomebrew())
{
s64 out;
svcGetSystemInfo(&out, 0x10000, 0);
homebrew = !out;
}
}
static void exit_services(void)
{
close_archives();
cfguExit();
ptmuExit();
if (old_time_limit != UINT32_MAX) APT_SetAppCpuTimeLimit(old_time_limit);
httpcExit();
acExit();
ndspExit();
}
static void stop_install_check(void)
{
for(int i = 0; i < MODE_AMOUNT; i++)
{
install_check_threads_arg[i].run_thread = false;
}
for(int i = 0; i < MODE_AMOUNT; i++)
{
if(install_check_threads[i] == NULL)
continue;
threadJoin(install_check_threads[i], U64_MAX);
threadFree(install_check_threads[i]);
install_check_threads[i] = NULL;
}
}
static void exit_thread(void)
{
if(iconLoadingThread_arg.run_thread)
{
DEBUG("exiting thread\n");
iconLoadingThread_arg.run_thread = false;
svcReleaseMutex(update_icons_mutex);
svcWaitSynchronization(update_icons_mutex, U64_MAX);
threadJoin(iconLoadingThread, U64_MAX);
threadFree(iconLoadingThread);
iconLoadingThread = NULL;
}
}
void free_lists(void)
{
stop_install_check();
for(int i = 0; i < MODE_AMOUNT; i++)
{
Entry_List_s * const current_list = &lists[i];
C3D_TexDelete(&current_list->icons_texture);
free(current_list->icons_info);
free(current_list->entries);
memset(current_list, 0, sizeof(Entry_List_s));
}
exit_thread();
}
void exit_function(bool power_pressed)
{
if(audio)
{
stop_audio(&audio);
}
free_lists();
svcCloseHandle(update_icons_mutex);
exit_screens();
exit_services();
if(!power_pressed && installed_themes)
{
if(homebrew)
{
APT_HardwareResetAsync();
}
else
{
srvPublishToSubscriber(0x202, 0);
}
}
}
static void start_thread(void)
{
if(iconLoadingThread_arg.run_thread)
{
DEBUG("starting thread\n");
iconLoadingThread = threadCreate(load_icons_thread, &iconLoadingThread_arg, __stacksize__, 0x38, -2, false);
}
}
static u32 next_or_equal_power_of_2(u32 v)
{
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
static void load_lists(Entry_List_s * lists)
{
free_lists();
for(int i = 0; i < MODE_AMOUNT; i++)
{
InstallType loading_screen = INSTALL_NONE;
if(i == MODE_THEMES)
loading_screen = INSTALL_LOADING_THEMES;
else if(i == MODE_SPLASHES)
loading_screen = INSTALL_LOADING_SPLASHES;
draw_install(loading_screen);
Entry_List_s * const current_list = &lists[i];
current_list->mode = i;
current_list->entries_per_screen_v = entries_per_screen_v[i];
current_list->entries_per_screen_h = 1;
current_list->entries_loaded = current_list->entries_per_screen_v * current_list->entries_per_screen_h;
current_list->entry_size = entry_size[i];
const int x_component = max(current_list->entries_per_screen_h, current_list->entries_per_screen_v);
const int y_component = min(current_list->entries_per_screen_h, current_list->entries_per_screen_v);
// A texture must have power of 2 dimensions (not necessarily the same)
// so, get the power of two greater than or equal to:
// - the size of the largest length (row or column) of icons for the width
// - the size of all of those lengths to fit the total for the height
C3D_TexInit(&current_list->icons_texture,
next_or_equal_power_of_2(x_component * current_list->entry_size),
next_or_equal_power_of_2(y_component * current_list->entry_size * ICONS_OFFSET_AMOUNT),
GPU_RGB565);
C3D_TexSetFilter(&current_list->icons_texture, GPU_NEAREST, GPU_NEAREST);
const float inv_width = 1.0f / current_list->icons_texture.width;
const float inv_height = 1.0f / current_list->icons_texture.height;
current_list->icons_info = (Entry_Icon_s *)calloc(x_component * y_component * ICONS_OFFSET_AMOUNT, sizeof(Entry_Icon_s));
for(int j = 0; j < y_component * ICONS_OFFSET_AMOUNT; ++j)
{
const int index = j * x_component;
for(int h = 0; h < x_component; ++h)
{
Entry_Icon_s * const icon_info = &current_list->icons_info[index + h];
icon_info->x = h * current_list->entry_size;
icon_info->y = j * current_list->entry_size;
icon_info->subtex.width = current_list->entry_size;
icon_info->subtex.height = current_list->entry_size;
icon_info->subtex.left = icon_info->x * inv_width;
icon_info->subtex.top = 1.0f - (icon_info->y * inv_height);
icon_info->subtex.right = icon_info->subtex.left + (icon_info->subtex.width * inv_width);
icon_info->subtex.bottom = icon_info->subtex.top - (icon_info->subtex.height * inv_height);
}
}
Result res = load_entries(main_paths[i], current_list, loading_screen);
if(R_SUCCEEDED(res))
{
if(current_list->entries_count > current_list->entries_loaded * ICONS_OFFSET_AMOUNT)
iconLoadingThread_arg.run_thread = true;
DEBUG("total: %i\n", current_list->entries_count);
sort_by_name(current_list);
load_icons_first(current_list, false);
void (*install_check_function)(void *) = NULL;
if(i == MODE_THEMES)
install_check_function = themes_check_installed;
else if(i == MODE_SPLASHES)
install_check_function = splash_check_installed;
Thread_Arg_s * current_arg = &install_check_threads_arg[i];
current_arg->run_thread = true;
current_arg->thread_arg = (void **)current_list;
if(install_check_function != NULL)
{
install_check_threads[i] = threadCreate(install_check_function, current_arg, __stacksize__, 0x3f, -2, false);
svcSleepThread(1e8);
}
}
}
start_thread();
}
static SwkbdCallbackResult jump_menu_callback(void * entries_count, const char ** ppMessage, const char * text, size_t textlen)
{
(void)textlen;
int typed_value = atoi(text);
if(typed_value > *(int *)entries_count)
{
*ppMessage = language.main.position_too_big;
return SWKBD_CALLBACK_CONTINUE;
}
else if(typed_value == 0)
{
*ppMessage = language.main.position_zero;
return SWKBD_CALLBACK_CONTINUE;
}
return SWKBD_CALLBACK_OK;
}
static void jump_menu(Entry_List_s * list)
{
if(list == NULL) return;
char numbuf[64] = {0};
SwkbdState swkbd;
sprintf(numbuf, "%i", list->entries_count);
int max_chars = strlen(numbuf);
swkbdInit(&swkbd, SWKBD_TYPE_NUMPAD, 2, max_chars);
sprintf(numbuf, "%i", list->selected_entry);
swkbdSetInitialText(&swkbd, numbuf);
sprintf(numbuf, language.main.jump_q);
swkbdSetHintText(&swkbd, numbuf);
swkbdSetButton(&swkbd, SWKBD_BUTTON_LEFT, language.main.cancel, false);
swkbdSetButton(&swkbd, SWKBD_BUTTON_RIGHT, language.main.jump, true);
swkbdSetValidation(&swkbd, SWKBD_NOTEMPTY_NOTBLANK, 0, max_chars);
swkbdSetFilterCallback(&swkbd, jump_menu_callback, &list->entries_count);
memset(numbuf, 0, sizeof(numbuf));
SwkbdButton button = swkbdInputText(&swkbd, numbuf, sizeof(numbuf));
if(button == SWKBD_BUTTON_CONFIRM)
{
list->selected_entry = atoi(numbuf) - 1;
list->scroll = list->selected_entry;
if(list->scroll >= list->entries_count - list->entries_loaded)
list->scroll = list->entries_count - list->entries_loaded - 1;
if (list->scroll < 0)
list->scroll = 0;
}
}
static void change_selected(Entry_List_s * list, int change_value)
{
if(abs(change_value) >= list->entries_count) return;
int newval = list->selected_entry + change_value;
if(newval < 0)
newval += list->entries_count;
newval %= list->entries_count;
list->selected_entry = newval;
}
static void toggle_shuffle(Entry_List_s * list)
{
Entry_s * current_entry = &list->entries[list->selected_entry];
if(current_entry->in_shuffle)
{
if(current_entry->no_bgm_shuffle)
{
current_entry->in_shuffle = false;
current_entry->no_bgm_shuffle = false;
list->shuffle_count--;
}
else
{
current_entry->no_bgm_shuffle = true;
}
}
else
{
current_entry->in_shuffle = true;
list->shuffle_count++;
}
}
static inline void wait_scroll(void)
{
released = true;
svcReleaseMutex(update_icons_mutex);
svcSleepThread(FASTSCROLL_WAIT);
}
int main(void)
{
srand(time(NULL));
init_services();
CFG_Language lang;
CFGU_GetSystemLanguage(&lang);
language = init_strings(lang);
init_screens();
svcCreateMutex(&update_icons_mutex, true);
static Entry_List_s * current_list = NULL;
void * iconLoadingThread_args_void[] = {
&current_list,
&update_icons_mutex,
};
iconLoadingThread_arg.thread_arg = iconLoadingThread_args_void;
iconLoadingThread_arg.run_thread = false;
#ifndef CITRA_MODE
if(R_SUCCEEDED(archive_result))
load_lists(lists);
#else
load_lists(lists);
#endif
EntryMode current_mode = MODE_THEMES;
bool preview_mode = false;
int preview_offset = 0;
bool install_mode = false;
DrawMode draw_mode = DRAW_MODE_LIST;
bool extra_mode = false;
int extra_index = 1;
C2D_Image preview = {0};
while(aptMainLoop())
{
if(quit)
{
free_preview(preview);
exit_function(false);
return 0;
}
if (aptCheckHomePressRejected() && !home_displayed)
{
time_home_pressed = svcGetSystemTick() / CPU_TICKS_PER_MSEC;
home_displayed = true;
}
#ifndef CITRA_MODE
if(R_FAILED(archive_result) && current_mode == MODE_THEMES)
{
throw_error(language.main.no_theme_extdata, ERROR_LEVEL_ERROR);
quit = true;
continue;
}
#endif
hidScanInput();
u32 kDown = hidKeysDown();
u32 kHeld = hidKeysHeld();
u32 kUp = hidKeysUp();
current_list = &lists[current_mode];
Instructions_s instructions = language.normal_instructions[current_mode];
if(install_mode)
instructions = language.install_instructions;
if(extra_mode)
{
instructions = language.extra_instructions[extra_index];
}
if(preview_mode)
{
draw_preview(preview, preview_offset);
}
else {
if(!iconLoadingThread_arg.run_thread)
{
handle_scrolling(current_list);
current_list->previous_scroll = current_list->scroll;
}
else
{
if(!released)
{
svcReleaseMutex(update_icons_mutex);
released = true;
}
svcWaitSynchronization(update_icons_mutex, U64_MAX);
}
draw_interface(current_list, instructions, draw_mode);
svcSleepThread(1e7);
released = false;
}
if (home_displayed)
{
u64 cur_time = svcGetSystemTick() / CPU_TICKS_PER_MSEC;
draw_home(time_home_pressed, cur_time);
if (cur_time - time_home_pressed > 2000) home_displayed = false;
}
end_frame();
if(kDown & KEY_START) quit = true;
if(current_list->entries_count == 0)
{
if (kDown & KEY_R)
{
goto enable_qr;
} else if (kDown & KEY_L)
{
goto switch_mode;
} else if (kDown & KEY_TOUCH)
{
touchPosition touch = {0};
hidTouchRead(&touch);
u16 x = touch.px;
u16 y = touch.py;
if (y < 24)
{
if(BETWEEN(320-24, x, 320))
{
goto switch_mode;
} else if(BETWEEN(320-48, x, 320-24))
{
quit = true;
continue;
} else if(BETWEEN(320-72, x, 320-48))
{
goto browse_themeplaza;
} else if(BETWEEN(320-96, x, 320-72))
{
goto enable_qr;
}
}
}
}
else if(!install_mode && !extra_mode)
{
if(!preview_mode && kDown & KEY_L) //toggle between splashes and themes
{
switch_mode:
current_mode++;
current_mode %= MODE_AMOUNT;
continue;
}
else if(!preview_mode && kDown & KEY_R) //toggle QR mode
{
enable_qr:
draw_base_interface();
draw_text_center(GFX_TOP, 100, 0.5f, 0.6f, 0.6f, colors[COLOR_WHITE], language.main.loading_qr);
end_frame();
if(R_SUCCEEDED(camInit()))
{
camExit();
u32 out;
ACU_GetWifiStatus(&out);
if(out)
{
if(init_qr())
{
load_lists(lists);
}
}
else
{
throw_error(language.main.no_wifi, ERROR_LEVEL_WARNING);
}
}
else
{
if(homebrew)
throw_error(language.main.qr_homebrew, ERROR_LEVEL_WARNING);
else
throw_error(language.main.camera_broke, ERROR_LEVEL_WARNING);
}
continue;
}
else if(kDown & KEY_Y && current_list->entries != NULL) //toggle preview mode
{
toggle_preview:
if(!preview_mode)
{
preview_mode = load_preview(current_list, &preview, &preview_offset);
if(preview_mode)
{
end_frame();
draw_preview(preview, preview_offset);
end_frame();
if(current_mode == MODE_THEMES && dspfirm)
{
audio = calloc(1, sizeof(audio_s));
Result r = load_audio(&current_list->entries[current_list->selected_entry], audio);
if (R_SUCCEEDED(r)) play_audio(audio);
else audio = NULL;
}
}
}
else
{
preview_mode = false;
if(current_mode == MODE_THEMES && audio)
{
stop_audio(&audio);
}
}
continue;
}
else if(preview_mode && kDown & (KEY_B | KEY_TOUCH))
{
preview_mode = false;
if(current_mode == MODE_THEMES && audio)
{
stop_audio(&audio);
}
continue;
}
}
if(preview_mode || current_list->entries == NULL)
goto touch;
int selected_entry = current_list->selected_entry;
Entry_s * current_entry = &current_list->entries[selected_entry];
if(install_mode)
{
if ((kDown | kHeld) & KEY_TOUCH)
{
touchPosition touch = {0};
hidTouchRead(&touch);
u16 x = touch.px;
u16 y = touch.py;
if (kDown & KEY_TOUCH)
{
if (y < 24)
{
if (BETWEEN(320-24, x, 320))
{
goto install_theme_single;
} else if (BETWEEN(320-48, x, 320-24))
{
goto install_theme_shuffle;
} else if (BETWEEN(320-72, x, 320-48))
{
goto install_theme_no_bgm;
} else if (BETWEEN(320-96, x, 320-72))
{
goto install_theme_bgm_only;
} else if (BETWEEN(320-120, x, 320-96))
{
goto install_leave;
}
}
}
}
if(kDown & KEY_B)
{
install_leave:
install_mode = false;
draw_mode = DRAW_MODE_LIST;
}
else if(kDown & KEY_DLEFT)
{
install_theme_bgm_only:
install_mode = false;
draw_mode = DRAW_MODE_LIST;
aptSetHomeAllowed(false);
draw_install(INSTALL_BGM);
if(R_SUCCEEDED(bgm_install(current_entry)))
{
for(int i = 0; i < current_list->entries_count; i++)
{
#define BETWEEN(min, x, max) (min < x && x < max)
Entry_s * theme = &current_list->entries[i];
if(theme == current_entry)
theme->installed = true;
else
theme->installed = false;
}
installed_themes = true;
}
}
else if(kDown & KEY_DUP)
{
install_theme_single:
install_mode = false;
draw_mode = DRAW_MODE_LIST;
aptSetHomeAllowed(false);
draw_install(INSTALL_SINGLE);
if(R_SUCCEEDED(theme_install(current_entry)))
{
for(int i = 0; i < current_list->entries_count; i++)
{
Entry_s * theme = &current_list->entries[i];
if(theme == current_entry)
theme->installed = true;
else
theme->installed = false;
}
installed_themes = true;
}
}
else if(kDown & KEY_DRIGHT)
{
install_theme_no_bgm:
install_mode = false;
draw_mode = DRAW_MODE_LIST;
aptSetHomeAllowed(false);
draw_install(INSTALL_NO_BGM);
if(R_SUCCEEDED(no_bgm_install(current_entry)))
{
for(int i = 0; i < current_list->entries_count; i++)
{
Entry_s * theme = &current_list->entries[i];
if(theme == current_entry)
theme->installed = true;
else
theme->installed = false;
}
installed_themes = true;
}
}
else if(kDown & KEY_DDOWN)
{
install_theme_shuffle:
install_mode = false;
draw_mode = DRAW_MODE_LIST;
if(current_list->shuffle_count > MAX_SHUFFLE_THEMES)
{
throw_error(language.main.too_many_themes, ERROR_LEVEL_WARNING);
}
else if(current_list->shuffle_count < 2)
{
throw_error(language.main.not_enough_themes, ERROR_LEVEL_WARNING);
}
else
{
aptSetHomeAllowed(false);
draw_install(INSTALL_SHUFFLE);
Result res = shuffle_install(current_list);
if(R_FAILED(res)) DEBUG("shuffle install result: %lx\n", res);
else
{
for(int i = 0; i < current_list->entries_count; i++)
{
Entry_s * theme = &current_list->entries[i];
if(theme->in_shuffle)
{
theme->in_shuffle = false;
theme->installed = true;
}
else theme->installed = false;
}
current_list->shuffle_count = 0;
installed_themes = true;
}
}
}
continue;
}
else if(extra_mode)
{
if((kDown | kHeld) & KEY_TOUCH)
{
touchPosition touch = {0};
hidTouchRead(&touch);
u16 x = touch.px;
u16 y = touch.py;
if (kDown & KEY_TOUCH)
{
if (y < 24)
{
if (BETWEEN(320-24, x, 320))
{
goto browse_themeplaza;
} else if (BETWEEN(320-48, x, 320-24))
{
goto dump_single;
} else if (BETWEEN(320-72, x, 320-48))
{
switch (current_list->current_sort)
{
case SORT_NAME:
goto sort_author;
break;
case SORT_AUTHOR:
goto sort_path;
break;
case SORT_PATH:
goto sort_name;
break;
default:
break;
}
} else if (BETWEEN(320-96, x, 320-72))
{
extra_mode = false;
extra_index = 1;
draw_mode = DRAW_MODE_LIST;
}
}
}
}
else if(extra_index == 1)
{
if(kDown & KEY_B)
{
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
}
else if(kDown & KEY_DLEFT)
{
browse_themeplaza:
if(themeplaza_browser(current_mode))
{
current_mode = MODE_THEMES;
load_lists(lists);
}
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown & KEY_DUP)
{
jump:
jump_menu(current_list);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown & KEY_DDOWN)
{
load_icons_first(current_list, false);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if (kDown & KEY_DRIGHT)
{
draw_install(INSTALL_BADGES);
install_badges();
}
else if (kDown & KEY_R)
{
extra_index = 2;
}
else if(kDown & KEY_L)
{
extra_index = 0;
}
}
else if(extra_index == 0)
{
if(kDown & KEY_DLEFT)
{
sort_path:
sort_by_filename(current_list);
load_icons_first(current_list, false);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown & KEY_DUP)
{
sort_name:
sort_by_name(current_list);
load_icons_first(current_list, false);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown & KEY_DDOWN)
{
sort_author:
sort_by_author(current_list);
load_icons_first(current_list, false);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if (kDown & KEY_B)
{
extra_index = 1;
}
}
else if(extra_index == 2)
{
if(kDown & KEY_DUP)
{
dump_single:
draw_install(INSTALL_DUMPING_THEME);
Result res = dump_current_theme();
if (R_FAILED(res)) DEBUG("Dump theme result: %lx\n", res);
else load_lists(lists);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown & KEY_DDOWN)
{
draw_install(INSTALL_DUMPING_ALL_THEMES);
Result res = dump_all_themes();
if (R_FAILED(res)) DEBUG("Dump all themes result: %lx\n", res);
else load_lists(lists);
extra_mode = false;
draw_mode = DRAW_MODE_LIST;
extra_index = 1;
}
else if(kDown &KEY_B)
{
extra_index = 1;
}
}
continue;
}
// Actions
if(kDown & KEY_A)
{
switch(current_mode)
{
case MODE_THEMES:
install_mode = true;
draw_mode = DRAW_MODE_INSTALL;
break;
case MODE_SPLASHES:
draw_install(INSTALL_SPLASH);
splash_install(current_entry);
for(int i = 0; i < current_list->entries_count; i++)
{
Entry_s * splash = &current_list->entries[i];
if(splash == current_entry)
splash->installed = true;
else
splash->installed = false;
}
break;
default:
break;
}
}
else if(kDown & KEY_B)
{
switch(current_mode)
{
case MODE_THEMES:
toggle_shuffle(current_list);
break;
case MODE_SPLASHES:
if(draw_confirm(language.main.uninstall_confirm, current_list, draw_mode))
{
draw_install(INSTALL_SPLASH_DELETE);
splash_delete();
}
break;
default:
break;
}
}
else if(kDown & KEY_X)
{
extra_mode = true;
draw_mode = DRAW_MODE_EXTRA;
}
else if(kDown & KEY_SELECT)
{
if(draw_confirm(language.main.delete_confirm, current_list, draw_mode))
{
draw_install(INSTALL_ENTRY_DELETE);
delete_entry(current_entry, current_entry->is_zip);
load_lists(lists);
}
}
// Movement in the UI
else if(kDown & KEY_UP)
{
change_selected(current_list, -1);
}
else if(kDown & KEY_DOWN)
{
change_selected(current_list, 1);
}
// Quick moving
else if(kDown & KEY_LEFT)
{
change_selected(current_list, -current_list->entries_per_screen_v);
}
else if(kDown & KEY_RIGHT)
{
change_selected(current_list, current_list->entries_per_screen_v);
}
// Fast scroll using circle pad
else if(kHeld & KEY_CPAD_UP)
{
change_selected(current_list, -1);
wait_scroll();
}
else if(kHeld & KEY_CPAD_DOWN)
{
change_selected(current_list, 1);
wait_scroll();
}
else if(kHeld & KEY_CPAD_LEFT)
{
change_selected(current_list, -current_list->entries_per_screen_v);
wait_scroll();
}
else if(kHeld & KEY_CPAD_RIGHT)
{
change_selected(current_list, current_list->entries_per_screen_v);
wait_scroll();
}
// Movement using the touchscreen
touch:
if((kDown | kHeld) & KEY_TOUCH)
{
touchPosition touch = {0};
hidTouchRead(&touch);
u16 x = touch.px;
u16 y = touch.py;
u16 arrowStartX = 136;
u16 arrowEndX = arrowStartX+16;
if(kDown & KEY_TOUCH)
{
if(y < 24)
{
if(BETWEEN(320-168, x, 320-144))
{
if (current_mode == MODE_THEMES)
{
toggle_shuffle(current_list);
}
}
else if(BETWEEN(320-144, x, 320-120))
{
extra_mode = true;
draw_mode = DRAW_MODE_EXTRA;
}
else if(BETWEEN(320-120, x, 320-96))
{
if (current_mode == MODE_THEMES)
{
install_mode = true;
draw_mode = DRAW_MODE_INSTALL;
} else if (current_mode == MODE_SPLASHES)
{
draw_install(INSTALL_SPLASH);
splash_install(current_entry);
for(int i = 0; i < current_list->entries_count; i++)
{
Entry_s * splash = &current_list->entries[i];
if(splash == current_entry)
splash->installed = true;
else
splash->installed = false;
}
}
}
else if(BETWEEN(320-96, x, 320-72))
{
goto enable_qr;
}
else if(BETWEEN(320-72, x, 320-48))
{
quit = true;
}
else if(BETWEEN(320-48, x, 320-24))
{
goto toggle_preview;
}
else if(BETWEEN(320-24, x, 320))
{
goto switch_mode;
}
}
else if(y >= 216)
{
if(current_list->entries != NULL && BETWEEN(arrowStartX, x, arrowEndX) && current_list->scroll > 0)
{
change_selected(current_list, -current_list->entries_per_screen_v);
}
else if(current_list->entries != NULL && BETWEEN(arrowStartX + 16, x, arrowEndX + 16) && current_list->scroll < current_list->entries_count - current_list->entries_per_screen_v)
{
change_selected(current_list, current_list->entries_per_screen_v);
}
else if(current_list->entries != NULL && BETWEEN(176, x, 320))
{
goto jump;
}
}
}
else
{
if(current_list->entries != NULL && BETWEEN(24, y, 216))
{
for(int i = 0; i < current_list->entries_loaded; i++)
{
u16 miny = 24 + current_list->entry_size * i;
u16 maxy = miny + current_list->entry_size;
if(BETWEEN(miny, y, maxy) && current_list->scroll + i < current_list->entries_count)
{
current_list->selected_entry = current_list->scroll + i;
break;
}
}
}
}
}
}
free_preview(preview);
// aptSetHomeAllowed(true);
exit_function(true);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink