void Handle_Home(int disable_screenshot)
{
if (CFG.home == CFG_HOME_EXIT) {
Con_Clear();
printf("\n");
printf_("Exiting...");
__console_flush(0);
Sys_Exit();
} else if (CFG.home == CFG_HOME_SCRSHOT) {
__console_flush(0);
Make_ScreenShot();
if (disable_screenshot) CFG.home = CFG_HOME_EXIT;
} else if (CFG.home == CFG_HOME_HBC) {
Con_Clear();
printf("\n");
printf_("HBC...");
__console_flush(0);
Sys_HBC();
} else if (CFG.home == CFG_HOME_REBOOT) {
Con_Clear();
Restart();
} else {
// Priiloader magic words, and channels
if ((CFG.home & 0xFF) < 'a') {
// upper case final letter implies channel
Con_Clear();
Sys_Channel(CFG.home);
} else {
// lower case final letter implies magic word
Con_Clear();
*(vu32*)0x8132FFFB = CFG.home;
Restart();
}
}
}
void input_t::loop(){
SDL_PumpEvents();
SDL_Event event;
input_keyboard_map_t *keyboard_map = nullptr;
try{
keyboard_map = (input_keyboard_map_t*)find_pointer(keyboard_map_id);
throw_if_nullptr(keyboard_map);
}catch(std::logic_error &e){
return;
}
keyboard_map->array.data_lock.lock();
while(SDL_PollEvent(&event)){
switch(event.type){
case SDL_KEYUP:
printf_("DEBUG: SDL_KEYUP was received\n", PRINTF_DEBUG);
keyboard_map->keyboard_map[entry_from_scancode(event.key.keysym.scancode)] = false;
break;
case SDL_KEYDOWN:
printf_("DEBUG: SDL_KEYDOWN was received\n", PRINTF_DEBUG);
keyboard_map->keyboard_map[entry_from_scancode(event.key.keysym.scancode)] = true;
break;
default:
// not supported yet, but this should be enough for simple control
break;
}
}
keyboard_to_signal();
keyboard_map->array.data_lock.unlock();
}
void __WBFS_Spinner(s32 x, s32 max)
{
static time_t start;
static u32 expected;
f32 percent, size;
u32 d, h, m, s;
/* First time */
if (!x) {
start = time(0);
expected = 300;
}
/* Elapsed time */
d = time(0) - start;
if (x != max) {
/* Expected time */
if (d && x)
expected = (expected * 3 + d * max / x) / 4;
/* Remaining time */
d = (expected > d) ? (expected - d) : 1;
}
/* Calculate time values */
h = d / 3600;
m = (d / 60) % 60;
s = d % 60;
/* Calculate percentage/size */
percent = (x * 100.0) / max;
if (hdd) {
size = (hdd->wii_sec_sz / GB_SIZE) * max;
} else {
size = (0x8000 / GB_SIZE) * max;
}
Con_ClearLine();
/* Show progress */
if (x != max) {
printf_(gt("%.2f%% of %.2fGB (%c) ETA: %d:%02d:%02d"),
percent, size, "/-\\|"[(x / 10) % 4], h, m, s);
printf("\r");
fflush(stdout);
} else {
printf_(gt("%.2fGB copied in %d:%02d:%02d"), size, h, m, s);
printf(" \n");
}
__console_flush(1);
}
void child1_thread()
{
while (1)
{
char c = uart_read();
printf_("char >%c<\n", c);
led_on(LED_1);
printf_("child 1 thread 1111111\n");
led_off(LED_1);
timer_delay_ms(300);
}
}
udp_socket_t::udp_socket_t(array_id_t tmp_connection_info_id){
connection_info_id = tmp_connection_info_id;
net_ip_connection_info_t *tmp = (net_ip_connection_info_t*)find_pointer(connection_info_id);
socket = nullptr;
if(tmp == nullptr){
printf_("The net_ip_connection_info_t that this socket has to use does not exist (ID: " + std::to_string(tmp_connection_info_id) + ")\n", PRINTF_ERROR);
}else{
socket = SDLNet_UDP_Open(tmp->port);
if(unlikely(!socket)){
printf_("Socket will not open (port: " + std::to_string(tmp->port) + ")\n", PRINTF_VITAL);
assert(false);
}
}
}
void set_signal(int signal, bool value){
if(unlikely(signal > SIGNAL_ARRAY_SIZE || signal < 0)){
printf_("ERROR: signal is out of bounds\n", PRINTF_ERROR);
return;
}
signal_array[signal-1] = value;
}
s32 WBFS_Init(u32 device, u32 timeout)
{
u32 cnt;
s32 ret = -1;
/* Wrong timeout */
if (!timeout)
return -1;
/* Try to mount device */
for (cnt = 0; cnt < timeout; cnt++) {
ret = WBFS_Init_Dev(device);
if (ret >= 0) break;
Gui_Console_Enable();
printf("%d ", cnt + 1);
/* Sleep 1 second */
sleep(1);
}
printf_("%s\n", ret < 0 ? gt("ERROR!") : gt("OK!"));
return ret;
}
static void net_send_data(){
int_ what_to_update = INT_MAX;
std::vector<array_id_t> client_vector = all_ids_of_type("client_t");
const uint_ client_vector_size = client_vector.size();
if(client_vector_size == 0){
return;
}
if(once_per_second){
const std::string reset_vector = wrap(ARRAY_FUNCTION_START, "reset_vector", ARRAY_FUNCTION_END);
for(uint_ i = 0;i < client_vector_size;i++){
net->write(reset_vector, ((client_t*)find_pointer(client_vector[i], "coord_t"))->connection_info_id);
}
}
std::vector<std::string> data_to_send = generate_outbound_class_data();
for(uint_ c = 0;c < data_to_send.size();c++){
for(uint_ i = 0;i < client_vector_size;i++){
client_t *tmp_client = (client_t*)find_pointer(client_vector[i], "client_t");
if(tmp_client != nullptr){
if(find_pointer(tmp_client->connection_info_id, "net_ip_connection_info_t") == nullptr){
printf_("WARNING: Found an addressless client", PRINTF_UNUSUAL_WARN);
}else{
net->write(gen_string, tmp_client->connection_info_id);
}
}
}
}
}
int FLASH_write(char* argv){
/* Porgram FLASH Bank1 ********************************************************/
/* Unlock the Flash Bank1 Program Erase controller */
char *pData;
int need_erase = 0;
char buffer[20];
int Data=0x87654321;
int Address,FLASHStatus;
Address = atoi(argv);
pData = strchr(argv,SEP_FIELD);
pData++;
Data = atoi(pData);
sprintf(buffer,"\naddr:%x\n",Address);
printf_(buffer);
sprintf(buffer,"\ndata:%x\n",Data);
printf_(buffer);
if ( *(__IO uint32_t*)Address != 0xffffffff)
need_erase =1;
FLASH_UnlockBank1();
if ( need_erase!=0 ){
printf_("\r\nNeeds erasing page first!erase now...\r\n");
}
/* Define the number of page to be erased */
if ( (Address&0x3) !=0){
printf_("\r\nError:Address must align by four bytes!");
return 3; //3, 命令参数无效
}
FLASH_ProgramWord(Address, Data);
FLASH_LockBank1();
return 0;
/* Check the correctness of written data */
//~ Address = BANK1_WRITE_START_ADDR;
//~ while((Address < BANK1_WRITE_END_ADDR) && (MemoryProgramStatus != FAILED))
//~ {
//~ if((*(__IO uint32_t*) Address) != Data)
//~ {
//~ MemoryProgramStatus = FAILED;
//~ }
//~ Address += 4;
//~ }
}
int_ net_ip_t::send_now(net_ip_write_buffer_t *data){
int_ return_value = 0;
net_ip_connection_info_t *tmp_conn = (net_ip_connection_info_t*)find_pointer(data->connection_info_id, "net_ip_connection_info_t");
if(outbound == NULL){
printf("Cannot use outbound port. Check to see if you have proper permissions to use raw sockets\n");
return_value = -1;
return return_value;
}
uint_ position = 0;
if(tmp_conn != nullptr){
std::vector<std::string> raw_packets;
std::string data_prefix = wrap(NET_PACKET_ID_START, std::to_string(data->packet_id), NET_PACKET_ID_END);
if(data->data.size() > NET_MTU-NET_MTU_OVERHEAD){
while(data->data != ""){
uint_ chunk = NET_MTU-NET_MTU_OVERHEAD;
std::string pos_prefix = wrap(NET_PACKET_POS_START, std::to_string( position), NET_PACKET_POS_END);
std::string tmp_string = data_prefix + pos_prefix + data->data.substr(0,chunk);
raw_packets.push_back(tmp_string);
if(chunk > data->data.size()){
break;
}
data->data = data->data.substr(chunk, data->data.size());
position++;
}
}else{
std::string tmp;
tmp = wrap(NET_PACKET_ID_START, std::to_string(data->packet_id), NET_PACKET_ID_END);
tmp += wrap(NET_PACKET_POS_START, "0", NET_PACKET_POS_END);
tmp += data->data;
raw_packets.push_back(tmp);
}
const uint_ raw_packets_size = raw_packets.size();
raw_packets[0] = NET_PACKET_START + raw_packets[0];
raw_packets[raw_packets_size-1] += NET_PACKET_END;
IPaddress IP;
SDLNet_ResolveHost(&IP, tmp_conn->ip.c_str(), (unsigned short int)tmp_conn->port);
outbound_packet->address.host = IP.host;
outbound_packet->address.port = IP.port;
uint_ total_byte_size = 0;
const uint_ max_total_sent_byte = 8*KILOBYTE_TO_BYTE;
for(uint_ i = 0;i < raw_packets_size;i++){
negative_to_positive_trick(&raw_packets[i]);
unsigned char* outbound_data = (unsigned char *)raw_packets[i].c_str();
outbound_packet->len = (int)(raw_packets[i].size()+1);
outbound_packet->data = outbound_data;
SDLNet_UDP_Send(outbound->socket, -1, outbound_packet);
total_byte_size += outbound_packet->len;
if(unlikely(total_byte_size > max_total_sent_byte)){
// no packet loss if the client is sending data to itself
total_byte_size = 0;
loop_receive();
}
}
raw_packets.clear();
}else{
printf_("The connection ID (" + std::to_string(data->connection_info_id) + ") does not match up with anything here\n", PRINTF_STATUS);
}
return return_value;
}
float get_hal_pin(HPNAME name){
for(int i = 0; i < hal.hal_pin_count; i++){
if(!strcmp(hal.hal_pins[i]->name, name)){
return(hal.hal_pins[i]->source->source->value);
}
}
printf_("get not possible %s\n", name);
return(0.0);
}
int register_hal_pin(struct hal_pin* pin){
if(hal.hal_pin_count >= MAX_HAL_PINS){
printf_("reg hal pin: too many pins: %i\n", hal.hal_pin_count);
return(0);
}
for(int i = 0; i < hal.hal_pin_count; i++){
if(!strcmp(hal.hal_pins[i]->name, pin->name)){
printf_("reg hal pin: name fault: %s\n", pin->name);
return(0);
}
}
hal.hal_pins[hal.hal_pin_count] = pin;
hal.hal_pin_count++;
return(1);
}
void main_thread()
{
led_on(LED_1);
printf_(OS_WELCOME_MESSAGE);
create_thread(child1_thread, child1_thread_stack, sizeof(child1_thread_stack), PRIORITY_MAX);
create_thread(child2_thread, child2_thread_stack, sizeof(child2_thread_stack), PRIORITY_MAX);
while (1)
{
led_on(LED_1);
printf_("main thread\n");
led_off(LED_1);
timer_delay_ms(500);
}
}
void Restart(void)
{
printf("\n");
printf_(gt("Restarting Wii..."));
fflush(stdout);
__console_flush(0);
/* Load system menu */
Sys_LoadMenu();
}
void child2_thread()
{
while (1)
{
led_on(LED_1);
printf_("child 2 thread 2222222\n");
led_off(LED_1);
timer_delay_ms(700);
}
}
int set_hal_pin(HPNAME name, float value){
for(int i = 0; i < hal.hal_pin_count; i++){
if(!strcmp(hal.hal_pins[i]->name, name)){
hal.hal_pins[i]->value = value;
hal.hal_pins[i]->source = hal.hal_pins[i];
return(1);
}
}
printf_("set not possible %s = %f\n", name, value);
return(0);
}
void main_thread()
{
printf_(OS_WELCOME_MESSAGE);
u32 res = hmc5883_init();
while (1)
{
led_on(LED_1);
hmc5883_read();
//printf_("%u : %i %i %i\n", res, g_hmc5883.mx, g_hmc5883.my, g_hmc5883.mz);
printf_("%u : %i \n", res, g_hmc5883.mz);
led_off(LED_1);
timer_delay_ms(100);
}
robot_main();
}
void Restart_Wait(void)
{
printf("\n");
printf_(gt("Press any button to restart..."));
fflush(stdout);
/* Wait for button */
Wpad_WaitButtonsCommon();
/* Restart */
Restart();
}
void Menu_DumpBCA(u8 *id)
{
int ret;
char fname[100];
memset(BCA_Data, 0, 64);
printf_("\n");
printf_(gt("Reading BCA..."));
printf("\n\n");
ret = WDVD_Read_Disc_BCA(BCA_Data);
hex_dump3(BCA_Data, 64);
printf_("\n");
if (ret) {
printf_(gt("ERROR reading BCA!"));
printf("\n\n");
goto out;
}
// save
snprintf(D_S(fname), "%s/%.6s.bca", USBLOADER_PATH, (char*)id);
if (!Menu_Confirm(gt("save"))) return;
printf("\n");
printf_(gt("Writing: %s"), fname);
printf("\n\n");
FILE *f = fopen(fname, "wb");
if (!f) {
printf_(gt("ERROR writing BCA!"));
printf("\n\n");
goto out;
}
fwrite(BCA_Data, 64, 1, f);
fclose(f);
out:
Menu_PrintWait();
}
bool input_t::query_key(int scancode){
bool return_value = false;
if(likely(scancode > 0 && scancode < KEYBOARD_MAP_SIZE)){
try{
input_keyboard_map_t *keyboard_map = (input_keyboard_map_t*)find_pointer(keyboard_map_id);
throw_if_nullptr(keyboard_map);
return_value = keyboard_map->keyboard_map[scancode];
}catch(std::logic_error &e){}
}else{
printf_("ERROR: The scancode is outside of the keyboard bounds. You might be trying to acess some special variable (mouse control, joystick control, etc.)\n", PRINTF_ERROR);
return_value = false;
}
return return_value;
}
int set_comp_type(HPNAME name){
for(int i = 0; i < hal.comp_type_count; i++){
if(!strcmp(hal.comp_types[i], name)){
hal.comp_type = i;
return(hal.comp_types_counter[hal.comp_type]++);
}
}
if(hal.comp_type_count < MAX_COMP_TYPES){
strncpy(hal.comp_types[hal.comp_type_count], name, MAX_HPNAME);
hal.comp_type = hal.comp_type_count++;
return(0);
}
printf_("set comp type: too many comps types: %i\n", hal.comp_type_count);
return(-1);
}
int link_hal_pins(HPNAME source, HPNAME sink){
struct hal_pin* d;
struct hal_pin* s;
d = find_hal_pin(source);
s = find_hal_pin(sink);
if(d != 0 && s != 0){
// if(s->source != s){
// printf_("relink %s:%i -> %s:%i to %s:%i -> %s:%i\n", s->source->name, s->source, sink, s, source, d, sink, s);
// }
s->value = s->source->source->value;
s->source = d;
return(1);
}
printf_("link not possible %s:%i -> %s:%i\n", source, d, sink, s);
return(0);
}
void input_engine(){
try{
input_t *input = (input_t*)find_pointer(all_ids_of_type("input_t")[0]);
throw_if_nullptr(input);
input->array.data_lock.lock(); // no throws are allowed beyond this point
client_t *self = (client_t*)find_pointer(self_id);
if(self != nullptr && self->keyboard_map_id != DEFAULT_INT_VALUE){
input->array.data_lock.unlock();
input->set_keyboard_map_id(self->keyboard_map_id);
input->array.data_lock.lock();
}
input->loop();
if(input->query_key(SDL_SCANCODE_ESCAPE)){
set_signal(SIGTERM, true);
}
input->array.data_lock.unlock();
}catch(std::logic_error &e){
printf_("WARNING: input_t: cannot use the input library yet\n", PRINTF_UNLIKELY_WARN);
}
}
int FLASH_read(char* argv){
uint32_t i=0,len =32,data=0;
char buffer[buffer_sz];
char* pHead,*pEnd;
uint32_t address = 0x08000800;
if (*argv){
pHead = argv;
pEnd = strchr(pHead,SEP_FIELD);
if (pEnd) {
*pEnd = '\0';
address = atoi(pHead);
if (address < 0x08000000 && address >0x0800ffff) // for 64kBytes flash MCU
return 4; //4, 超出命令范围 in uart.c
pHead = pEnd +1;
if (*pHead)
len = atoi(pHead);
if (len<0 && len > 1024)
return 4; //4, 超出命令范围 in uart.c
}
}
printf_("\r\n");
printf_hex((char*)address,(int) len);
return 0;
}
void Print_SYS_Info()
{
FgColor(CFG.color_inactive);
printf_("");
Fat_print_sd_mode();
printf_(gt("CFG base: %s"), USBLOADER_PATH);
printf("\n");
if (strcmp(LAST_CFG_PATH, USBLOADER_PATH)) {
// if last cfg differs, print it out
printf_(gt("Additional config:"));
printf("\n");
printf_(" %s/config.txt\n", LAST_CFG_PATH);
}
printf_(gt("Loader Version: %s"), CFG_VERSION);
printf("\n");
printf_("IOS%u (Rev %u)\n",
IOS_GetVersion(), IOS_GetRevision());
DefaultColor();
}
void Menu_Boot()
{
struct discHdr *header;
bool gc = false;
header = &gameList[gameSelected];
s32 ret;
struct Game_CFG_2 *game_cfg = NULL;
/* Clear console */
if (!CFG.direct_launch) {
Con_Clear();
}
FgColor(CFG.color_header);
printf_x(gt("Start this game?"));
printf("\n\n");
DefaultColor();
game_cfg = CFG_find_game(header->id);
// Get game size
gc = header->magic == GC_MAGIC;
bool do_skip = !CFG.confirm_start;
/*
SoundInfo snd;
u8 banner_title[84];
memset(banner_title, 0, 84);
memset(&snd, 0, sizeof(snd));
WBFS_Banner(header->id, &snd, banner_title, !do_skip, CFG_read_active_game_setting(header->id).write_playlog);
*/
if (do_skip) {
goto skip_confirm;
}
printf("\n");
/* Show game info */
printf_("%s\n", get_title(header));
printf_("(%.6s)\n\n", header->id);
__Menu_ShowGameInfo(true, header->id); /* load game info from XML */
printf("\n");
//Does DL warning apply to launching discs too? Not sure
printf_h(gt("Press %s button to continue."), (button_names[CFG.button_confirm.num]));
printf("\n");
printf_h(gt("Press %s button to go back."), (button_names[CFG.button_cancel.num]));
if (!gc) {
printf("\n");
printf_h(gt("Press %s button for options."), (button_names[CFG.button_other.num]));
}
printf("\n\n");
__console_flush(0);
// play banner sound
/*
if (snd.dsp_data) {
SND_PauseVoice(0, 1); // pause mp3
int fmt = (snd.channels == 2) ? VOICE_STEREO_16BIT : VOICE_MONO_16BIT;
SND_SetVoice(1, fmt, snd.rate, 0,
snd.dsp_data, snd.size,
255,255, //volume,volume,
NULL); //DataTransferCallback
}
*/
/* Wait for user answer */
u32 buttons;
for (;;) {
buttons = Wpad_WaitButtons();
if (buttons & CFG.button_confirm.mask) break;
if (buttons & CFG.button_cancel.mask) break;
if (!gc && (buttons & CFG.button_other.mask)) break;
if (buttons & CFG.button_exit.mask) break;
}
/*
// stop banner sound, resume mp3
if (snd.dsp_data) {
SND_StopVoice(1);
SAFE_FREE(snd.dsp_data);
if (buttons & CFG.button_confirm.mask) {
SND_ChangeVolumeVoice(0, 0, 0);
}
SND_PauseVoice(0, 0);
}
*/
if (buttons & CFG.button_cancel.mask) goto close;
if (buttons & CFG.button_exit.mask) {
Handle_Home(0);
return;
}
if (!gc && (buttons & CFG.button_other.mask)) {
Menu_Boot_Options(header);
return;
}
// A button: continue to boot
skip_confirm:
if (game_cfg) {
CFG.game = game_cfg->curr;
}
if (CFG.game.write_playlog && set_playrec(header->id, (u8 *) header->title) < 0) { // banner_title) < 0) {
printf_(gt("Error storing playlog file.\nStart from the Wii Menu to fix."));
printf("\n");
printf_h(gt("Press %s button to exit."), (button_names[CFG.button_exit.num]));
printf("\n");
if (!Menu_Confirm(0)) return;
}
WBFS_OpenDisc(header->id, header->game_idx);
printf("\n");
printf_x(gt("Booting Wii game, please wait..."));
printf("\n\n");
// load stuff before ios reloads & services close
ocarina_load_code(header->id);
load_wip_patches(header->id);
// Close the wode stuff
WBFS_Close();
use_dvdx = 0;
Disc_Init();
ret = Disc_Wait();
if (ret < 0) {
printf("Cannot mount newly selected image: %d\n", ret);
}
Disc_Open();
// stop services (music, gui)
Services_Close();
setPlayStat(header->id); //I'd rather do this after the check, but now you unmount fat before that ;)
Fat_UnmountAll();
if (gc) {
WII_Initialize();
ret = WII_LaunchTitle(0x0000000100000100ULL);
} else {
switch(CFG.game.language)
{
// 0 = CFG_LANG_CONSOLE
case 0: configbytes[0] = 0xCD; break;
case 1: configbytes[0] = 0x00; break;
case 2: configbytes[0] = 0x01; break;
case 3: configbytes[0] = 0x02; break;
case 4: configbytes[0] = 0x03; break;
case 5: configbytes[0] = 0x04; break;
case 6: configbytes[0] = 0x05; break;
case 7: configbytes[0] = 0x06; break;
case 8: configbytes[0] = 0x07; break;
case 9: configbytes[0] = 0x08; break;
case 10: configbytes[0] = 0x09; break;
}
/* Boot Wii disc */
ret = Disc_WiiBoot();
}
printf_(gt("Returned! (ret = %d)"), ret);
printf("\n");
printf("\n");
printf_(gt("Press any button to exit..."));
printf("\n");
/* Wait for button */
Wpad_WaitButtonsCommon();
exit(0);
close:
WDVD_StopMotor();
header = &gameList[gameSelected];
Gui_DrawCover(header->id);
// Reopen the wode
WBFS_Init();
return;
}
void DoAction(int action)
{
if (action & CFG_BTN_REMAP) return;
switch(action) {
case CFG_BTN_NOTHING:
break;
case CFG_BTN_OPTIONS:
if (!CFG.disable_options) Menu_Options();
break;
case CFG_BTN_GUI:
if (go_gui) {
action_string[0] = 0;
action_alpha=0;
}
if (CFG.gui) go_gui = !go_gui;
break;
case CFG_BTN_REBOOT:
Con_Clear();
Restart();
break;
case CFG_BTN_EXIT:
Con_Clear();
printf("\n");
printf_("Exiting...");
__console_flush(0);
Sys_Exit();
break;
case CFG_BTN_SCREENSHOT:
__console_flush(0);
Make_ScreenShot();
CFG.home = CFG_HOME_EXIT;
break;
case CFG_BTN_MAIN_MENU:
Menu_Views();
break;
case CFG_BTN_GLOBAL_OPS:
if (!CFG.disable_options) Menu_Global_Options();
break;
case CFG_BTN_PROFILE:
if (CFG.current_profile == CFG.num_profiles-1)
CFG.current_profile = 0;
else
CFG.current_profile++;
Switch_Favorites(enable_favorite);
sprintf(action_string, gt("Profile: %s"), CFG.profile_names[CFG.current_profile]);
break;
case CFG_BTN_FAVORITES:
{
extern void reset_sort_default();
reset_sort_default();
Switch_Favorites(!enable_favorite);
}
break;
case CFG_BTN_BOOT_GAME:
Menu_Boot(0);
break;
case CFG_BTN_BOOT_DISC:
Menu_Boot(1);
break;
case CFG_BTN_THEME:
CFG_switch_theme(cur_theme + 1);
if (gameCnt) Gui_DrawCover(gameList[gameSelected].id);//redraw_cover = 1;
Cache_Invalidate();
sprintf(action_string, gt("Theme: %s"), theme_list[cur_theme]);
if (go_gui) action_alpha = 0xFF;
break;
case CFG_BTN_UNLOCK:
if (CFG.admin_lock) Menu_Unlock();
break;
case CFG_BTN_HBC:
Con_Clear();
printf("\n");
printf_("HBC...");
__console_flush(0);
Sys_HBC();
break;
case CFG_BTN_SORT:
if (sort_desc) {
sort_desc = 0;
if (sort_index == sortCnt - 1)
sort_index = 0;
else
sort_index = sort_index + 1;
sortList(sortTypes[sort_index].sortAsc);
} else {
sort_desc = 1;
sortList(sortTypes[sort_index].sortDsc);
}
if (gameCnt) Gui_DrawCover(gameList[gameSelected].id);//redraw_cover = 1;
sprintf(action_string, gt("Sort: %s-%s"), sortTypes[sort_index].name, (sort_desc) ? "DESC":"ASC");
break;
case CFG_BTN_FILTER:
Menu_Filter();
break;
default:
// Priiloader magic words, and channels
if ((action & 0xFF) < 'a') {
// upper case final letter implies channel
Con_Clear();
Sys_Channel(action);
} else {
// lower case final letter implies magic word
Con_Clear();
*(vu32*)0x8132FFFB = action;
Restart();
}
break;
}
}
void Menu_Partition(bool must_select)
{
int i;
s32 ret = 0;
int pnum = WBFS_GetPartitionCount();
struct Menu menu;
char active[256];
menu_init(&menu, pnum);
menu_init_active(&menu, active, 256);
loop:
menu_begin(&menu);
/* Clear console */
Con_Clear();
FgColor(CFG.color_header);
printf_x(gt("Select a partition"));
printf(":\n\n");
DefaultColor();
printf_("P# Name\n");
printf_("-----------------------------\n");
// P#1 ram1ro
// P#2 sda1ro
// P#3 sda2ro
char partname[32];
for (i = 0; i < pnum; i++) {
memset(partname, 0, 32);
WBFS_GetPartitionName(i, (char *) &partname);
MENU_MARK();
printf("%d %s\n", i, partname);
}
printf("\n");
printf_h(gt("Press %s button to select."), (button_names[CFG.button_confirm.num]));
printf("\n");
printf_h(gt("Press %s button to go back."), (button_names[CFG.button_cancel.num]));
printf("\n");
u32 buttons = Wpad_WaitButtonsCommon();
menu_move(&menu, buttons);
// B button
if (buttons & CFG.button_cancel.mask) {
if (must_select) {
if (WBFS_Selected()) return;
printf("\n");
printf_(gt("No partition selected!"));
printf("\n");
sleep(2);
} else {
return;
}
}
// A button
if (buttons & CFG.button_confirm.mask) {
i = menu.current;
__console_flush(0);
ret = WBFS_OpenPart(i, CFG.partition);
if (ret == 0) {
if (must_select) {
// called from global options
__Menu_GetEntries();
}
return;
}
}
goto loop;
}
UDPsocket udp_socket_t::get_socket(){
if(socket == nullptr){
printf_("ERROR: Socket is null (net_ip_connection_info_t ID (striped): " + std::to_string(strip_id(connection_info_id)) + "\n", PRINTF_VITAL);
}
return socket;
}
void __Menu_ShowList(void)
{
FgColor(CFG.color_header);
if (enable_favorite) {
printf_x(gt("Favorite Games"));
printf(":\n");
} else {
if (!CFG.hide_header) {
printf_x(gt("Select the game you want to boot"));
printf(":\n");
}
}
DefaultColor();
if (CFG.console_mark_page && gameStart > 0) {
printf(" %s +", CFG.cursor_space);
}
printf("\n");
/* No game list*/
if (gameCnt) {
u32 cnt;
/* Print game list */
for (cnt = gameStart; cnt < gameCnt; cnt++) {
struct discHdr *header = &gameList[cnt];
/* Entries per page limit reached */
if ((cnt - gameStart) >= ENTRIES_PER_PAGE)
break;
if (gameSelected == cnt) {
FgColor(CFG.color_selected_fg);
BgColor(CFG.color_selected_bg);
Con_ClearLine();
} else {
DefaultColor();
}
/* Print entry */
//printf(" %2s %s\n", (gameSelected == cnt) ? ">>" : " ",
char *title = __Menu_PrintTitle(get_title(header));
// cursor
printf(" %s", (gameSelected == cnt) ? CFG.cursor : CFG.cursor_space);
// favorite mark
printf("%s", (CFG.console_mark_favorite && is_favorite(header->id))
? CFG.favorite : " ");
// title
printf("%s", title);
// saved mark
if (CFG.console_mark_saved) {
printf("%*s", (MAX_CHARACTERS - con_len(title)),
(CFG_is_saved(header->id)) ? CFG.saved : " ");
}
printf("\n");
}
DefaultColor();
if (CFG.console_mark_page && cnt < gameCnt) {
printf(" %s +", CFG.cursor_space);
} else {
printf(" %s ", CFG.cursor_space);
}
//if (CFG.hide_hddinfo) {
FgColor(CFG.color_footer);
BgColor(CONSOLE_BG_COLOR);
int num_page = 1 + (gameCnt - 1) / ENTRIES_PER_PAGE;
int cur_page = 1 + gameSelected / ENTRIES_PER_PAGE;
printf(" %-*.*s %d/%d", MAX_CHARACTERS - 8, MAX_CHARACTERS - 8, action_string, cur_page, num_page);
action_string[0] = 0;
//}
} else {
printf(" ");
printf(gt("%s No games found!!"), CFG.cursor);
printf("\n");
}
/* Print free/used space */
FgColor(CFG.color_footer);
BgColor(CONSOLE_BG_COLOR);
if (!CFG.hide_footer) {
printf("\n");
// (B) GUI (1) Options (2) Favorites
// B: GUI 1: Options 2: Favorites
//char c_gui = 'B', c_opt = '1';
//if (CFG.buttons == CFG_BTN_OPTIONS_B) {
// c_gui = '1'; c_opt = 'B';
//}
printf_("");
if (CFG.gui && CFG.button_gui) {
printf("%s: GUI ", (button_names[CFG.button_gui]));
}
if (!CFG.disable_options && CFG.button_opt) {
printf("%s: Options ", (button_names[CFG.button_opt]));
}
if (CFG.button_fav) {
printf("%s: Favorites", (button_names[CFG.button_fav]));
}
}
if (CFG.db_show_info) {
printf("\n");
//load game info from XML - lustar
__Menu_ShowGameInfo(false, gameList[gameSelected].id);
}
DefaultColor();
__console_flush(0);
}
