mirror of
https://gitee.com/anod/open_agb_firm.git
synced 2025-05-06 13:54:09 +08:00
765 lines
20 KiB
C
765 lines
20 KiB
C
/*
|
||
* This file is part of open_agb_firm
|
||
* Copyright (C) 2021 derrek, profi200
|
||
*
|
||
* 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/>.
|
||
*/
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdarg.h>
|
||
#include "types.h"
|
||
#include "error_codes.h"
|
||
#include "fs.h"
|
||
#include "util.h"
|
||
#include "arm11/drivers/hid.h"
|
||
#include "arm11/drivers/mcu.h"
|
||
#include "arm11/console.h"
|
||
#include "arm11/fmt.h"
|
||
#include "drivers/gfx.h"
|
||
#include "arm11/acf.h"
|
||
#include "arm11/atp.h"
|
||
#include "arm11/acl.h"
|
||
#include "arm11/cheat.h"
|
||
#include "arm11/pages.h"
|
||
#include "arm11/keyremix.h"
|
||
|
||
#define screenClean() memset(consoleGet()->frameBuffer, 0, CWIDTH*CHEIGHT*sizeof(uint16_t))
|
||
|
||
// Notes on these settings:
|
||
// MAX_ENT_BUF_SIZE should be big enough to hold the average file/dir name length * MAX_DIR_ENTRIES.
|
||
#define MAX_ENT_BUF_SIZE (1024u * 196) // 196 KiB.
|
||
#define MAX_DIR_ENTRIES (999u)
|
||
#define DIR_READ_BLOCKS (10u)
|
||
|
||
#define CWIDTH 320u
|
||
#define CHEIGHT 240u
|
||
|
||
#define ENT_TYPE_FILE (0)
|
||
#define ENT_TYPE_DIR (1)
|
||
|
||
typedef struct
|
||
{
|
||
u32 num; // Total number of entries.
|
||
char entBuf[MAX_ENT_BUF_SIZE]; // Format: char entryType; char name[X]; // null terminated.
|
||
char *ptrs[MAX_DIR_ENTRIES]; // For fast sorting.
|
||
} DirList;
|
||
|
||
int dlistCompare(const void *a, const void *b)
|
||
{
|
||
const char *entA = *(char**)a;
|
||
const char *entB = *(char**)b;
|
||
|
||
// Compare the entry type. Dirs have priority over files.
|
||
if(*entA != *entB) return (int)*entB - *entA;
|
||
|
||
// Compare the string.
|
||
int res;
|
||
do
|
||
{
|
||
res = *++entA - *++entB;
|
||
} while(res == 0 && *entA != '\0' && *entB != '\0');
|
||
|
||
return res;
|
||
}
|
||
|
||
static Result scanDir(const char *const path, DirList *const dList, const char *const filter, const char *match, int *index)
|
||
{
|
||
FILINFO *const fis = (FILINFO*)malloc(sizeof(FILINFO) * DIR_READ_BLOCKS);
|
||
if(fis == NULL) return RES_OUT_OF_MEM;
|
||
|
||
dList->num = 0;
|
||
|
||
Result res;
|
||
DHandle dh;
|
||
u32 received = 0;
|
||
if((res = fOpenDir(&dh, path)) == RES_OK)
|
||
{
|
||
u32 read; // Number of entries read by fReadDir().
|
||
u32 numEntries = 0; // Total number of processed entries.
|
||
u32 entBufPos = 0; // Entry buffer position/number of bytes used.
|
||
const u32 filterLen = strlen(filter);
|
||
do
|
||
{
|
||
if((res = fReadDir(dh, fis, DIR_READ_BLOCKS, &read)) != RES_OK) break;
|
||
received = numEntries + read;
|
||
read = (read <= MAX_DIR_ENTRIES - numEntries ? read : MAX_DIR_ENTRIES - numEntries);
|
||
|
||
for(u32 i = 0; i < read; i++)
|
||
{
|
||
const char entType = (fis[i].fattrib & AM_DIR ? ENT_TYPE_DIR : ENT_TYPE_FILE);
|
||
const u32 nameLen = strlen(fis[i].fname);
|
||
if(entType == ENT_TYPE_FILE)
|
||
{
|
||
if(nameLen <= filterLen || strcmp(filter, fis[i].fname + nameLen - filterLen) != 0)
|
||
continue;
|
||
}
|
||
|
||
// nameLen does not include the entry type and NULL termination.
|
||
if(entBufPos + nameLen + 2 > MAX_ENT_BUF_SIZE)
|
||
{
|
||
res = RES_PATH_TOO_LONG;
|
||
goto scanEnd;
|
||
}
|
||
|
||
char *const entry = &dList->entBuf[entBufPos];
|
||
*entry = entType;
|
||
safeStrcpy(&entry[1], fis[i].fname, 256);
|
||
dList->ptrs[numEntries++] = entry;
|
||
entBufPos += nameLen + 2;
|
||
}
|
||
} while(read == DIR_READ_BLOCKS);
|
||
|
||
scanEnd:
|
||
dList->num = numEntries;
|
||
|
||
fCloseDir(dh);
|
||
}
|
||
|
||
free(fis);
|
||
|
||
qsort(dList->ptrs, dList->num, sizeof(char*), dlistCompare);
|
||
|
||
if( match != NULL )
|
||
{
|
||
for( u32 i=0; i < dList->num; ++i )
|
||
{
|
||
if( strcmp(match, &dList->ptrs[i][1]) == 0 )
|
||
{
|
||
*index = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return received > MAX_DIR_ENTRIES ? RES_OUT_OF_RANGE : res;
|
||
}
|
||
|
||
static Result rom_get_serial( const char *file, char serial[5] )
|
||
{
|
||
FHandle f;
|
||
Result res;
|
||
u32 readed;
|
||
serial[0] = serial[4] = '\0';
|
||
if( RES_OK != (res=fOpen(&f, file, FA_OPEN_EXISTING | FA_READ)) )
|
||
{
|
||
return res;
|
||
}
|
||
if( RES_OK != (res=fLseek(f, 0xac)) )
|
||
{
|
||
fClose( f );
|
||
return res;
|
||
}
|
||
if( RES_OK != (res=fRead(f, serial, 4, &readed))
|
||
|| readed != 4 )
|
||
{
|
||
fClose(f);
|
||
return res;
|
||
}
|
||
fClose(f);
|
||
return RES_OK;
|
||
}
|
||
|
||
static atp_text_t folder_help[] = {
|
||
"操 作 说 明",
|
||
"~ ~ ~ ~ ~ ~ ~",
|
||
"蓝色 目录",
|
||
"白色 游戏",
|
||
"~ ~ ~ ~ ~ ~ ~",
|
||
"上下方向键 切换选中文件或目录",
|
||
"左右方向键 翻页",
|
||
"Ａ键 查看目录或启动游戏",
|
||
"Ｂ键 上层文件夹",
|
||
"Ｘ键 金手指",
|
||
"Ｙ键 配置游戏键位",
|
||
"ＳＴＡＲＴ 查看说明",
|
||
"ＳＥＬＥＣＴ 系统设置"
|
||
};
|
||
|
||
static atp_text_t cheat_off_help[] = {
|
||
"未启用金手指",
|
||
"如需开启，请进入系统设置菜单(SELECT键进入)",
|
||
"在“激活金手指”选项中启用金手指功能"
|
||
};
|
||
|
||
static atp_error_t display_folder( atp_callerdata_t data, atp_counter_t index, atp_itemcfg_t *config )
|
||
{
|
||
void* *dat = (void **)data;
|
||
DirList *const dList = (DirList*)dat[0];
|
||
u8 type = *dList->ptrs[index];
|
||
if( type == ENT_TYPE_DIR )
|
||
config->text_color = ATP_COLOR_BLUE;
|
||
config->text = &dList->ptrs[index][1];
|
||
config->value = index;
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
DECLARE_ERROR_PAGE( display_noserial, "提取游戏识别码失败" )
|
||
DECLARE_ERROR_PAGE( display_empty, "没有合适的文件" )
|
||
DECLARE_ERROR_PAGE( display_toolong, "路径过长，改名或移动文件后再试" )
|
||
DECLARE_ERROR_PAGE( display_pathfull, "游戏或目录过量，最多显示999个" )
|
||
DECLARE_ERROR_PAGE( display_longname, "文件名总计过长，只显示前面的文件" )
|
||
DECLARE_ERROR_PAGE( display_conflictkey, "和已有键位产生冲突" )
|
||
|
||
static atp_error_t disp_str( atp_callerdata_t data, atp_counter_t, atp_linecfg_t *cfg )
|
||
{
|
||
cfg->text = (atp_text_t)data;
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
/*void log( const char *fmt, ... ) {
|
||
char buf[512];
|
||
ee_puts("\x1b[2J");
|
||
|
||
va_list args;
|
||
va_start(args, fmt);
|
||
u32 res = ee_vsnprintf(buf, 512, fmt, args);
|
||
va_end(args);
|
||
ee_puts( buf );
|
||
|
||
uint32_t down;
|
||
do{
|
||
GFX_waitForVBlank0();
|
||
hidScanInput();
|
||
down = hidKeysDown();
|
||
}while ( down == 0 );
|
||
}*/
|
||
|
||
static inline void key_tips( key_remix_t *p, atp_boolean_t checking, atp_itemcfg_t *cfg )
|
||
{
|
||
if( p->remix_type == REMIX_TYPE_NONE )
|
||
{
|
||
cfg->extra_text = "未添加";
|
||
cfg->extra_text_color = ATP_COLOR_LIGHT;
|
||
}
|
||
else
|
||
{
|
||
if( p->remix_type == REMIX_TYPE_CHEAT )
|
||
{
|
||
if( checking && p->game_keys == 0)
|
||
{
|
||
cfg->extra_text = "配置不齐";
|
||
cfg->extra_text_color = ATP_COLOR_RED;
|
||
}
|
||
else
|
||
{
|
||
cfg->extra_text = "金手指键";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
}
|
||
else if( p->remix_type == REMIX_TYPE_REMAP )
|
||
{
|
||
if( checking && (p->game_keys==0 || p->device_keys==0) )
|
||
{
|
||
cfg->extra_text = "配置不齐";
|
||
cfg->extra_text_color = ATP_COLOR_RED;
|
||
}
|
||
else
|
||
{
|
||
cfg->extra_text = "键位映射";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
}
|
||
else if( p->remix_type == REMIX_TYPE_HOLD )
|
||
{
|
||
if( checking && (p->game_keys==0 || p->device_keys==0) )
|
||
{
|
||
cfg->extra_text = "配置不齐";
|
||
cfg->extra_text_color = ATP_COLOR_RED;
|
||
}
|
||
else
|
||
{
|
||
cfg->extra_text = "模拟长按";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#define KCP_OPTION_BASE 1000
|
||
static atp_error_t select_krp( atp_callerdata_t, atp_counter_t index, atp_itemcfg_t *cfg )
|
||
{
|
||
static char name[20];
|
||
if( index < KEY_REMIX_LIMIT )
|
||
{
|
||
ee_snprintf(name, sizeof(name), "键位配置项%ld", index+1);
|
||
cfg->text = name;
|
||
cfg->value = index;
|
||
key_remix_t *p = &g_keyremixConfig[index];
|
||
key_tips(p, 1, cfg);
|
||
}
|
||
else
|
||
{
|
||
cfg->text = index == KEY_REMIX_LIMIT ? "保存当前配置到SD卡" : "从SD卡加载已保存的配置";
|
||
cfg->value = KCP_OPTION_BASE + index-KEY_REMIX_LIMIT;
|
||
}
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
|
||
#define KRFIELD_REMIX 0
|
||
#define KRFIELD_DEVICE 1
|
||
#define KRFIELD_GAME 2
|
||
|
||
const char *key_name[] = {
|
||
"上", "下", "左", "右", "A", "B", "L", "R", "SELECT", "START", "X", "Y", "ZL", "ZR"
|
||
};
|
||
const u16 key_val[] = {
|
||
KEY_DUP, KEY_DDOWN, KEY_DLEFT, KEY_DRIGHT, KEY_A, KEY_B, KEY_L, KEY_R, KEY_SELECT, KEY_START, KEY_X, KEY_Y, KEY_ZL, KEY_ZR
|
||
};
|
||
#define key_val_len (sizeof(key_val)/sizeof(u16))
|
||
static atp_error_t select_kcf( atp_callerdata_t p, atp_counter_t index, atp_itemcfg_t *cfg )
|
||
{
|
||
key_remix_t *kcfg = (key_remix_t*)p;
|
||
if( index == KRFIELD_REMIX )
|
||
{
|
||
cfg->text = "选择键位功能";
|
||
key_tips(kcfg, 0, cfg);
|
||
}
|
||
else if( index == KRFIELD_DEVICE )
|
||
{
|
||
cfg->text = "选择实机键位";
|
||
if( kcfg->device_keys )
|
||
{
|
||
for( u8 i=0; i < key_val_len; ++i)
|
||
{
|
||
if( key_val[i] == kcfg->device_keys )
|
||
{
|
||
cfg->extra_text = key_name[i];
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
}
|
||
}
|
||
else if( kcfg->remix_type == REMIX_TYPE_CHEAT )
|
||
{
|
||
cfg->extra_text = "HOME";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
else
|
||
{
|
||
cfg->extra_text = "未设置";
|
||
cfg->extra_text_color = ATP_COLOR_LIGHT;
|
||
}
|
||
}
|
||
else if( index == KRFIELD_GAME )
|
||
{
|
||
cfg->text = "游戏中对应键位";
|
||
if( kcfg->game_keys == 0 )
|
||
{
|
||
cfg->extra_text = "未设置";
|
||
cfg->extra_text_color = ATP_COLOR_LIGHT;
|
||
}
|
||
else
|
||
{
|
||
cfg->extra_text = "已设置";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
}
|
||
cfg->value = index;
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
static atp_error_t select_remixtype( atp_callerdata_t, atp_counter_t index, atp_itemcfg_t *cfg )
|
||
{
|
||
if( index == REMIX_TYPE_NONE ) cfg->text = "停用设置";
|
||
else if( index == REMIX_TYPE_REMAP ) cfg->text = "键位映射";
|
||
else if( index == REMIX_TYPE_CHEAT ) cfg->text = "金手指键";
|
||
else if( index == REMIX_TYPE_HOLD ) cfg->text = "模拟长按";
|
||
cfg->value = index;
|
||
return ATP_SUCCESS;
|
||
}
|
||
static atp_error_t select_unikey( atp_callerdata_t str, atp_counter_t, atp_itemcfg_t *cfg )
|
||
{
|
||
cfg->text = (atp_text_t)str;
|
||
cfg->value = 0;
|
||
return ATP_SUCCESS;
|
||
}
|
||
static atp_error_t select_hostkey( atp_callerdata_t dat, atp_counter_t index, atp_itemcfg_t *cfg )
|
||
{
|
||
phykey_t k = (phykey_t)dat;
|
||
cfg->text = key_name[index];
|
||
cfg->value = key_val[index];
|
||
if( k == key_val[index] )
|
||
{
|
||
cfg->extra_text = "选中";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
static atp_error_t select_gbakey( atp_callerdata_t p_curkey, atp_counter_t index, atp_itemcfg_t *cfg )
|
||
{
|
||
conkey_t key = *(conkey_t*)p_curkey;
|
||
cfg->text = key_name[index];
|
||
cfg->value = key_val[index];
|
||
if( key & key_val[index] )
|
||
{
|
||
cfg->extra_text = "选中";
|
||
cfg->extra_text_color = ATP_COLOR_GREEN;
|
||
}
|
||
return ATP_SUCCESS;
|
||
}
|
||
|
||
static atp_error_t active_gbakey( atp_callerdata_t p_curkey, atp_counter_t index, atp_boolean_t x, atp_boolean_t y, atp_boolean_t l, atp_boolean_t r, atp_boolean_t start, atp_boolean_t select )
|
||
{
|
||
conkey_t *pkey = (conkey_t*)p_curkey;
|
||
if( x )
|
||
{
|
||
conkey_t res = *pkey & key_val[index];
|
||
if( res ) *pkey &= ~key_val[index];
|
||
else *pkey |= key_val[index];
|
||
return ATP_PAGE_UPDATE;
|
||
}
|
||
else return ATP_PAGE_NOOPTION;
|
||
}
|
||
|
||
extern atp_error_t oaf_config_page();
|
||
|
||
#define DIRBUFFSIZE 512
|
||
|
||
static atp_pageopt_t serve_on_key( atp_callerdata_t data, atp_counter_t index, atp_boolean_t x, atp_boolean_t y, atp_boolean_t l, atp_boolean_t r, atp_boolean_t start, atp_boolean_t select )
|
||
{
|
||
if( start )
|
||
{
|
||
return WAIT_ON_ACT( use_help_page( folder_help ) );
|
||
}
|
||
else if( select )
|
||
{
|
||
return WAIT_ON_ACT( oaf_config_page() );
|
||
}
|
||
else if( x )
|
||
{
|
||
if( CHEAT_MODE_DISABLED == oafCheatMode() )
|
||
return WAIT_ON_ACT( use_help_page(cheat_off_help) );
|
||
|
||
void* *dat = (void **)data;
|
||
DirList const *dList = (DirList*)dat[0];
|
||
char *path = (char*)dat[1];
|
||
|
||
const char *file = &dList->ptrs[index][1];
|
||
int pathlen = strlen(path);
|
||
int filelen = strlen(file);
|
||
|
||
if( pathlen + filelen > DIRBUFFSIZE - 1)
|
||
{
|
||
return WAIT_ON_ERRPAGE( display_toolong );
|
||
}
|
||
else if( ENT_TYPE_DIR == dList->ptrs[index][0] )
|
||
{
|
||
return WAIT_ON_ERRPAGE( display_empty );
|
||
}
|
||
|
||
path[pathlen] = '/';
|
||
safeStrcpy( path+pathlen+1, file, DIRBUFFSIZE - filelen );
|
||
|
||
#define RECOVER_PATH path[pathlen] = '\0'
|
||
// 确定game serial
|
||
char serial[5];
|
||
if( RES_OK != rom_get_serial(path, serial) )
|
||
{
|
||
RECOVER_PATH;
|
||
return WAIT_ON_ERRPAGE( display_noserial );
|
||
}
|
||
else RECOVER_PATH;
|
||
|
||
return WAIT_ON_ACT( use_cheat_page( serial ) );
|
||
}
|
||
else if( y )
|
||
{
|
||
#ifndef NDEBUG
|
||
extern u8 dump_patched_rom;
|
||
dump_patched_rom = 0;
|
||
#endif
|
||
atp_itemval_t position=0, field=0, value;
|
||
atp_error_t res;
|
||
atp_text_t oldtips;
|
||
atp_tips( "确定A/返回B", &oldtips );
|
||
|
||
#define DISP_DONE 0
|
||
#define DISP_KPOS 1
|
||
#define DISP_SETK 2 // SET KEY
|
||
#define DISP_KMAP 3 // REMUX TYPE
|
||
#define DISP_3DSK 4 // 3DS KEY
|
||
#define DISP_GBAK 5 // GBA KEY
|
||
|
||
uint8_t status = DISP_KPOS;
|
||
char tips[32];
|
||
while ( status != DISP_DONE )
|
||
{
|
||
if ( status == DISP_KPOS)
|
||
{
|
||
res = atp_select( "选择配置项后，按A进行键位配置", KEY_REMIX_LIMIT+2, select_krp, NULL, NULL, position, 0, &position );
|
||
if( res == ATP_SUCCESS )
|
||
{
|
||
void* *dat = (void **)data;
|
||
DirList const *dList = (DirList*)dat[0];
|
||
char *file = &dList->ptrs[index][1];
|
||
|
||
if( position < KEY_REMIX_LIMIT )
|
||
{
|
||
status = DISP_SETK;
|
||
field = 0;
|
||
}
|
||
else if( position == KCP_OPTION_BASE )
|
||
{
|
||
const char *err = keyremix_dump( file );
|
||
if( !err ) status = DISP_DONE;
|
||
else atp_show( 1, disp_str, err );
|
||
}
|
||
else
|
||
{
|
||
const char *err = keyremix_load( file );
|
||
if( !err ) position = 0;
|
||
else atp_show( 1, disp_str, err );
|
||
}
|
||
}
|
||
else break;
|
||
}
|
||
else if( status == DISP_SETK )
|
||
{
|
||
ee_snprintf(tips, sizeof(tips), "编辑配置项%ld", position+1);
|
||
key_remix_t *cur = &g_keyremixConfig[position];
|
||
res = atp_select( tips, 3, select_kcf, NULL, cur, field, 0, &field );
|
||
if( res == ATP_SUCCESS )
|
||
{
|
||
status = field == KRFIELD_REMIX ? DISP_KMAP : (field == KRFIELD_DEVICE ? DISP_3DSK : DISP_GBAK);
|
||
}
|
||
else if( res == ATP_NO_ACTION )
|
||
{
|
||
int fault = 0;
|
||
for( int i=0; i < KEY_REMIX_LIMIT; ++i )
|
||
{
|
||
if( i!=position )
|
||
{
|
||
if( g_keyremixConfig[i].remix_type == cur->remix_type
|
||
&& g_keyremixConfig[i].device_keys == cur->device_keys )
|
||
{
|
||
fault = 1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if( fault && cur->remix_type != REMIX_TYPE_NONE )
|
||
atp_show(1, display_conflictkey, NULL);
|
||
else status = DISP_KPOS;
|
||
}
|
||
else break;
|
||
}
|
||
else if( status == DISP_KMAP )
|
||
{
|
||
key_remix_t *cur = &g_keyremixConfig[position];
|
||
res = atp_select( "配置键位功能", REMIX_TYPE_COUNT, select_remixtype, NULL, cur->remix_type, 0, 0, &value );
|
||
if( res == ATP_SUCCESS )
|
||
{
|
||
if( cur->remix_type != value )
|
||
{
|
||
cur->remix_type = value;
|
||
cur->device_keys = 0;
|
||
cur->game_keys = value == REMIX_TYPE_CHEAT ? DEFAULT_CHEATKEY : 0;
|
||
}
|
||
status = DISP_SETK;
|
||
}
|
||
else if( res == ATP_NO_ACTION )
|
||
{
|
||
status = DISP_SETK;
|
||
}
|
||
else break;
|
||
}
|
||
else if( status == DISP_3DSK )
|
||
{
|
||
key_remix_t *cur = &g_keyremixConfig[position];
|
||
atp_counter_t keys_count = 12; // old 3ds, old 3dsLL, 2ds
|
||
u8 host = MCU_getSystemModel();// 0=3ds 1=3dsll 2=n3ds 3=2ds 4=n3dsll 5=n2dsll
|
||
atp_text_t text;
|
||
if( cur->remix_type == REMIX_TYPE_CHEAT )
|
||
{
|
||
keys_count = 1;
|
||
text = "HOME";
|
||
}
|
||
else if( host > 1 && host != 3 ) // N3DS/N3DSLL/N2DSLL
|
||
{
|
||
keys_count = 14;
|
||
}
|
||
u8 selected = 31;
|
||
for( u8 i=0; i < key_val_len; ++i )
|
||
{
|
||
if( key_val[i] == cur->device_keys )
|
||
{
|
||
selected = i;
|
||
break;
|
||
}
|
||
}
|
||
if( keys_count == 1 ) res = atp_select("选择实机键位（单选）", 1, select_unikey, NULL, text, 0, 0, &value);
|
||
else res = atp_select( "选择实机键位（单选）", keys_count, select_hostkey, NULL, cur->device_keys, selected>keys_count?0:selected, 0, &value);
|
||
if( res == ATP_SUCCESS )
|
||
{
|
||
cur->device_keys = value;
|
||
status = DISP_SETK;
|
||
}
|
||
else if( res == ATP_NO_ACTION )
|
||
{
|
||
status = DISP_SETK;
|
||
}
|
||
else break;
|
||
}
|
||
else if( status == DISP_GBAK )
|
||
{
|
||
key_remix_t *cur = &g_keyremixConfig[position];
|
||
conkey_t key_editing = cur->game_keys;
|
||
atp_text_t current;
|
||
atp_tips("选择X/确定A/返回B", ¤t);
|
||
res = atp_select( "选择游戏中对应键位[多选，按X键设置选中]", 10, select_gbakey, active_gbakey, &key_editing, 0, 0, &value);
|
||
atp_tips( current, NULL );
|
||
if( res == ATP_SUCCESS )
|
||
{
|
||
cur->game_keys = key_editing;
|
||
status = DISP_SETK;
|
||
}
|
||
else if( res == ATP_NO_ACTION )
|
||
{
|
||
status = DISP_SETK;
|
||
}
|
||
else break;
|
||
}
|
||
}
|
||
atp_tips( oldtips, NULL );
|
||
|
||
return WAIT_ON_ACT(res);
|
||
}
|
||
|
||
return ATP_PAGE_NOOPTION;
|
||
}
|
||
|
||
#define PATH_SAME 0
|
||
#define PATH_PUSH 1
|
||
#define PATH_POP 2
|
||
#define DIRUP { \
|
||
char *tmpPathPtr = curDir + pathLen; \
|
||
while(*--tmpPathPtr != '/'); \
|
||
if(*(tmpPathPtr - 1) == ':') tmpPathPtr++; \
|
||
*tmpPathPtr = '\0'; \
|
||
path_recover = PATH_POP; \
|
||
upFrom = tmpPathPtr + 1; \
|
||
}
|
||
Result browseFiles(const char *const basePath, char selected[512])
|
||
{
|
||
if(basePath == NULL || selected == NULL) return RES_INVALID_ARG;
|
||
// TODO: Check if the base path is empty.
|
||
|
||
char *curDir = (char*)malloc(DIRBUFFSIZE);
|
||
if(curDir == NULL) return RES_OUT_OF_MEM;
|
||
safeStrcpy(curDir, basePath, 512);
|
||
|
||
DirList *const dList = (DirList*)malloc(sizeof(DirList));
|
||
if(dList == NULL) return RES_OUT_OF_MEM;
|
||
|
||
Result res;
|
||
if((res = scanDir(curDir, dList, ".gba", NULL, NULL)) != RES_OK)
|
||
{
|
||
if( res == RES_OUT_OF_RANGE )
|
||
atp_show(1, display_pathfull, NULL);
|
||
else if( res == RES_PATH_TOO_LONG )
|
||
atp_show(1, display_longname, NULL );
|
||
else goto end;
|
||
}
|
||
|
||
const char *upFrom = NULL;
|
||
int selecting = 0;
|
||
while( 1 )
|
||
{
|
||
atp_itemval_t value;
|
||
atp_error_t error;
|
||
int path_recover = PATH_SAME;
|
||
const u32 count = dList->num;
|
||
|
||
u32 pathLen = strlen(curDir);
|
||
|
||
if( count > 0 )
|
||
{
|
||
GFX_waitForVBlank0();
|
||
hidScanInput();
|
||
atp_tips( "指引：按START", NULL );
|
||
void *cust[2] = {dList, curDir};
|
||
error = atp_select( curDir, count, display_folder, serve_on_key, (atp_callerdata_t)cust, selecting, 0, &value );
|
||
}
|
||
else error = atp_show( 1, display_empty, NULL );
|
||
|
||
if( error == ATP_POWER_OFF )
|
||
{
|
||
res = error;
|
||
break;
|
||
}
|
||
else if( error == ATP_SUCCESS )
|
||
{// 进入目录或文件
|
||
if( count == 0 )
|
||
{
|
||
DIRUP;
|
||
}
|
||
else
|
||
{
|
||
const char *fname = &dList->ptrs[value][1];
|
||
u32 namelen = strlen( fname ) + 1;
|
||
if( namelen + pathLen > DIRBUFFSIZE-1 )
|
||
{
|
||
atp_show( 1, display_toolong, NULL );
|
||
continue;
|
||
}
|
||
curDir[pathLen++] = '/';
|
||
safeStrcpy( curDir+pathLen, fname, DIRBUFFSIZE - namelen );
|
||
if( *dList->ptrs[value] == ENT_TYPE_FILE )
|
||
{
|
||
safeStrcpy( selected, curDir, 512 );
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
path_recover = PATH_PUSH;
|
||
selecting = 0;
|
||
upFrom = NULL;
|
||
}
|
||
}
|
||
}
|
||
else if( error == ATP_NO_ACTION )
|
||
{// 上层目录
|
||
if( strcmp(curDir, FS_DRIVE_NAMES) == 0 )
|
||
{
|
||
atp_show(1, disp_str, "没有上层目录");
|
||
}
|
||
else DIRUP;
|
||
}
|
||
|
||
if( path_recover )
|
||
{
|
||
if(RES_OK != (res = scanDir(curDir, dList, ".gba", upFrom, &selecting)) )
|
||
{
|
||
if( res == RES_OUT_OF_RANGE )
|
||
atp_show( 1, display_pathfull, NULL ); // give a warning for user, and keep show the list
|
||
else if( res == RES_PATH_TOO_LONG )
|
||
atp_show( 1, display_longname, NULL );
|
||
else break;
|
||
}
|
||
path_recover = PATH_SAME;
|
||
}
|
||
}
|
||
|
||
end:
|
||
free(dList);
|
||
free(curDir);
|
||
|
||
// Clear screen.
|
||
screenClean();
|
||
|
||
return res;
|
||
}
|