use super::*;
pub(super) struct PpcMenuDispatchContext<'a> {
pub(super) binding: &'a PpcImportBinding,
pub(super) cpu: &'a mut PpcCpu,
pub(super) memory: &'a mut PpcSectionMem,
pub(super) process_memory_manager: &'a mut ProcessNativeMemoryManager,
pub(super) heap_cursor: &'a mut u32,
pub(super) heap_limit: u32,
pub(super) last_mem_error: &'a mut i16,
pub(super) last_resource_error: &'a mut i16,
pub(super) handles: &'a mut Vec<PpcHandleRecord>,
pub(super) vfs_resources: &'a mut Vec<PpcVfsResourceRecord>,
pub(super) current_resource_refnum: i16,
pub(super) resource_policy: &'a SharedProcessResourcePolicy,
pub(super) toolbox_startup: &'a mut PpcToolboxStartupState,
pub(super) current_menu_list: &'a mut u32,
pub(super) gworlds: &'a [PpcGWorldRecord],
pub(super) screen_clut: &'a [[u16; 3]; 256],
pub(super) current_gworld: &'a mut u32,
pub(super) current_gdevice: &'a mut u32,
pub(super) event_queue: &'a mut EventQueue,
pub(super) input: PpcInputSnapshot,
}
pub(super) fn dispatch_menu_import(context: PpcMenuDispatchContext<'_>) -> Option<PpcImportAction> {
let PpcMenuDispatchContext {
binding,
cpu,
memory,
process_memory_manager,
heap_cursor,
heap_limit,
last_mem_error,
last_resource_error,
handles,
vfs_resources,
current_resource_refnum,
resource_policy,
toolbox_startup,
current_menu_list,
gworlds,
screen_clut,
current_gworld,
current_gdevice,
event_queue,
input,
} = context;
match binding.dispatcher_target {
PpcImportDispatcherTarget::InitMenus => {
let init_state = crate::menu_manager::evaluate_init_menus();
toolbox_startup.menus_initialized = true;
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, init_state.the_menu);
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
if *current_menu_list == 0 {
*current_menu_list = ppc_alloc_menu_list_handle_with_allocator(
&[],
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
*last_mem_error = if *current_menu_list == 0 {
PPC_MEM_FULL_ERR
} else {
ppc_set_current_menu_list(memory, *current_menu_list);
PPC_NO_ERR
};
} else {
let result = ppc_replace_menu_list_definition_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
*current_menu_list,
&PpcMenuListDefinition::default(),
);
*last_mem_error = result;
}
let _ = ppc_ensure_menu_color_table_handle_with_allocator(
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
ppc_load_menu_color_resource_with_allocator(
0,
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
);
if *current_menu_list != 0 && !toolbox_startup.host_menu_bar_hidden {
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
*current_menu_list,
screen_clut,
MenuColorTable::new(&menu_color_bytes),
);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::NewMenu => {
let params = crate::menu_manager::evaluate_new_menu_parameters(
cpu.gpr[3] as u16 as i16,
cpu.gpr[4],
);
let menu_proc = ppc_menu_definition_handle(
0,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
);
let menu = if menu_proc == 0 {
0
} else {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_alloc_new_menu(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_proc,
params.menu_id(),
params.title_ptr(),
)
};
*last_mem_error = if menu == 0 {
PPC_MEM_FULL_ERR
} else {
PPC_NO_ERR
};
toolbox_startup.menu_item_commands.forget(menu);
toolbox_startup.menu_item_refcons.forget(menu);
Some(PpcImportAction::Return(menu))
}
PpcImportDispatcherTarget::DisposeMenu => {
if let Some(params) =
crate::menu_manager::evaluate_dispose_menu_parameters(cpu.gpr[3])
{
let menu_handle = params.menu_handle();
for resource in vfs_resources
.iter_mut()
.filter(|resource| resource.handle == menu_handle)
{
resource.handle = 0;
}
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let _ = allocator.dispose_handle(
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
menu_handle,
);
toolbox_startup.menu_item_commands.forget(menu_handle);
toolbox_startup.menu_item_refcons.forget(menu_handle);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::GetMenu => {
let Some(params) =
crate::menu_manager::evaluate_get_menu_parameters(cpu.gpr[3] as u16 as i16)
else {
return Some(PpcImportAction::Return(0));
};
let menu_handle = ppc_load_menu_resource(
params.menu_id(),
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
);
if menu_handle != 0 {
if let Some(action) = ppc_dispatch_native_menu_definition_with_return(
cpu,
Some(process_memory_manager),
memory,
heap_cursor,
heap_limit,
vfs_resources,
toolbox_startup,
MenuDefinitionInvocation::size(menu_handle),
cpu.lr,
PpcNativeReturnGpr3::Set(menu_handle),
) {
return Some(action);
}
ppc_calc_menu_size_with_resources(
memory,
menu_handle,
vfs_resources,
current_resource_refnum,
);
}
Some(PpcImportAction::Return(menu_handle))
}
PpcImportDispatcherTarget::GetItemCmd => {
if crate::menu_manager::evaluate_get_item_cmd_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
)
.is_some()
{
ppc_get_item_cmd(cpu, memory);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::SetItemCmd => {
let Some(params) = crate::menu_manager::evaluate_set_item_cmd_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5] as u8,
) else {
return Some(PpcImportAction::ReturnPreserve);
};
if crate::trap::dispatch::trace_input_enabled() {
eprintln!(
"[INPUT] PPC SetItemCmd menu=${:08X} item={} command=${:02X}",
params.menu_handle(),
params.item(),
params.cmd_char()
);
}
ppc_set_item_cmd(cpu, memory, handles);
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::GetItemMark => {
if crate::menu_manager::evaluate_get_item_mark_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
)
.is_some()
{
ppc_get_item_mark(cpu, memory);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::CountMItems => {
let params = crate::menu_manager::evaluate_count_m_items_parameters(cpu.gpr[3]);
Some(PpcImportAction::Return(u32::from(
ppc_count_menu_items(memory, params.menu_handle()),
)))
}
PpcImportDispatcherTarget::GetMenuItemText => {
if crate::menu_manager::evaluate_get_menu_item_text_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
)
.is_some()
{
ppc_get_menu_item_text(cpu, memory);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::SetMenuItemCommandID
| PpcImportDispatcherTarget::GetMenuItemCommandID
| PpcImportDispatcherTarget::SetMenuItemRefCon
| PpcImportDispatcherTarget::GetMenuItemRefCon => {
let menu = cpu.gpr[3];
let item = cpu.gpr[4] as u16;
let Some(items) = ppc_menu_items_from_memory(memory, menu).filter(|_| menu != 0) else {
return Some(PpcImportAction::Return(ppc_i16_result(-5623))); };
let params = match crate::menu_manager::evaluate_menu_item_property_parameters(
menu,
item,
cpu.gpr[5],
items.items.len(),
) {
Ok(params) => params,
Err(err) => return Some(PpcImportAction::Return(ppc_i16_result(err))),
};
let values = if matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::SetMenuItemRefCon
| PpcImportDispatcherTarget::GetMenuItemRefCon
) {
&mut toolbox_startup.menu_item_refcons
} else {
&mut toolbox_startup.menu_item_commands
};
if matches!(
binding.dispatcher_target,
PpcImportDispatcherTarget::SetMenuItemCommandID
| PpcImportDispatcherTarget::SetMenuItemRefCon
) {
values.set(params.menu_handle(), params.item(), params.value_or_ptr());
} else {
let output = params.value_or_ptr();
if output == 0 || !ppc_memory_can_write_bytes(memory, output, 4) {
return Some(PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR)));
}
let _ = memory.write_u32_be(output, values.get(params.menu_handle(), params.item()));
}
Some(PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR)))
}
PpcImportDispatcherTarget::SetMenuItemText => {
let Some(_params) = crate::menu_manager::evaluate_set_menu_item_text_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5],
) else {
return Some(PpcImportAction::ReturnPreserve);
};
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let result = ppc_set_menu_item_text_with_allocator(
cpu,
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::DeleteMenuItem => {
let result = if let Some(params) = crate::menu_manager::evaluate_delete_menu_item_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
) {
let old_count = ppc_count_menu_items(memory, params.menu_handle());
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let res = ppc_delete_menu_item_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
params.menu_handle(),
params.item(),
);
if res == PPC_NO_ERR && ppc_count_menu_items(memory, params.menu_handle()) < old_count {
toolbox_startup.menu_item_commands.delete(params.menu_handle(), params.item() as u16);
toolbox_startup.menu_item_refcons.delete(params.menu_handle(), params.item() as u16);
}
res
} else if cpu.gpr[3] == 0 {
PPC_NIL_HANDLE_ERR
} else {
PPC_NO_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::CalcMenuSize => {
if crate::menu_manager::evaluate_calc_menu_size_parameters(cpu.gpr[3]).is_some() {
Some(ppc_dispatch_calc_menu_size(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
vfs_resources,
current_resource_refnum,
toolbox_startup,
))
} else {
Some(PpcImportAction::ReturnPreserve)
}
}
PpcImportDispatcherTarget::PopUpMenuSelect => {
let _params = crate::menu_manager::evaluate_popup_menu_select_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5] as u16 as i16,
cpu.gpr[6] as u16 as i16,
);
ppc_step_menu_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
current_resource_refnum,
)
}
PpcImportDispatcherTarget::InsertMenu => {
let result = if let Some(params) = crate::menu_manager::evaluate_insert_menu_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
) {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_insert_menu_with_allocator(
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
params.menu_handle(),
params.before_id(),
)
} else {
PPC_PARAM_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::DeleteMenu => {
let params = crate::menu_manager::evaluate_delete_menu_parameters(
cpu.gpr[3] as u16 as i16,
);
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let result = ppc_delete_menu_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
*current_menu_list,
params.menu_id(),
);
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::AppendMenu => {
let result = if let Some(params) = crate::menu_manager::evaluate_append_menu_parameters(
cpu.gpr[3],
cpu.gpr[4],
) {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
ppc_insert_menu_items_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
params.menu_handle(),
params.data_ptr(),
i16::MAX,
)
} else {
PPC_NIL_HANDLE_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::InsertMenuItem => {
let result = if let Some(params) = crate::menu_manager::evaluate_insert_menu_item_parameters(
cpu.gpr[3],
cpu.gpr[4],
cpu.gpr[5] as u16 as i16,
) {
let old_count = ppc_count_menu_items(memory, params.menu_handle());
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let res = ppc_insert_menu_items_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
params.menu_handle(),
params.data_ptr(),
params.after_item(),
);
if res == PPC_NO_ERR {
let added = ppc_count_menu_items(memory, params.menu_handle()).saturating_sub(old_count);
let insert_index = params.insertion_index(old_count);
toolbox_startup.menu_item_commands.insert(params.menu_handle(), insert_index, added);
toolbox_startup.menu_item_refcons.insert(params.menu_handle(), insert_index, added);
}
res
} else {
PPC_NIL_HANDLE_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::AppendResMenu => {
let result = if let Some(params) = crate::menu_manager::evaluate_append_res_menu_parameters(
cpu.gpr[3],
cpu.gpr[4],
) {
ppc_insert_resource_menu(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
resource_policy,
last_resource_error,
params.menu_handle(),
params.res_type(),
i16::MAX,
)
} else {
PPC_NIL_HANDLE_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::InsertResMenu => {
let result = if let Some(params) = crate::menu_manager::evaluate_insert_res_menu_parameters(
cpu.gpr[3],
cpu.gpr[4],
cpu.gpr[5] as u16 as i16,
) {
let old_count = ppc_count_menu_items(memory, params.menu_handle());
let res = ppc_insert_resource_menu(
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
resource_policy,
last_resource_error,
params.menu_handle(),
params.res_type(),
params.after_item(),
);
if res == PPC_NO_ERR {
let added = ppc_count_menu_items(memory, params.menu_handle()).saturating_sub(old_count);
let insert_index = params.insertion_index(old_count);
toolbox_startup.menu_item_commands.insert(params.menu_handle(), insert_index, added);
toolbox_startup.menu_item_refcons.insert(params.menu_handle(), insert_index, added);
}
res
} else {
PPC_NIL_HANDLE_ERR
};
*last_mem_error = result;
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::EnableMenuItem => {
if let Some(params) = crate::menu_manager::evaluate_enable_menu_item_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
) {
ppc_set_menu_item_enabled(memory, handles, params.menu_handle(), params.item(), params.enabled());
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::DisableMenuItem => {
if let Some(params) = crate::menu_manager::evaluate_disable_menu_item_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
) {
ppc_set_menu_item_enabled(memory, handles, params.menu_handle(), params.item(), params.enabled());
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::SetItemMark => {
if crate::menu_manager::evaluate_set_item_mark_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5] as u8,
)
.is_some()
{
ppc_set_item_mark(cpu, memory, handles);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::CheckItem => {
if crate::menu_manager::evaluate_check_item_parameters(
cpu.gpr[3],
cpu.gpr[4] as u16 as i16,
cpu.gpr[5] & 0xff != 0,
)
.is_some()
{
ppc_check_menu_item(cpu, memory, handles);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::GetMenuBar => {
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
Some(PpcImportAction::Return(ppc_get_menu_bar_with_allocator(
*current_menu_list,
Some(&mut allocator),
None,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
)))
}
PpcImportDispatcherTarget::GetNewMBar => {
let Some(params) =
crate::menu_manager::evaluate_get_new_mbar_parameters(cpu.gpr[3] as u16 as i16)
else {
return Some(PpcImportAction::Return(0));
};
let result_handle = ppc_get_new_mbar(
params.menu_bar_id(),
process_memory_manager,
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
vfs_resources,
current_resource_refnum,
last_resource_error,
);
if result_handle == 0 {
return Some(PpcImportAction::Return(0));
}
let menu_handles = ppc_menu_list_definition(memory, result_handle)
.map(|menu_list| menu_list.handles().collect())
.unwrap_or_default();
if toolbox_startup
.execution
.calls()
.begin_menu_bar_build(
MenuBarBuild::new(result_handle, menu_handles),
MenuBarCallOrigin::PowerPc {
return_address: cpu.lr,
},
)
.is_none()
{
return Some(PpcImportAction::Return(0));
}
Some(ppc_continue_menu_bar_build(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
toolbox_startup,
vfs_resources,
current_resource_refnum,
))
}
PpcImportDispatcherTarget::ClearMenuBar => {
let clear_state = crate::menu_manager::evaluate_clear_menu_bar();
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
if *current_menu_list != 0 {
let mut menu_list =
ppc_menu_list_definition(memory, *current_menu_list).unwrap_or_default();
menu_list.clear_entries();
let result = ppc_replace_menu_list_definition_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
*current_menu_list,
&menu_list,
);
*last_mem_error = result;
if *last_mem_error == PPC_NO_ERR {
let _ = memory.write_u16_be(PPC_THE_MENU_ADDR, clear_state.the_menu);
}
}
ppc_clear_menu_color_table_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
);
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::SetMenuBar => {
let Some(params) =
crate::menu_manager::evaluate_set_menu_bar_parameters(cpu.gpr[3])
else {
*last_mem_error = PPC_PARAM_ERR;
return Some(PpcImportAction::ReturnPreserve);
};
let source = params.menu_list_handle();
let Some(menu_list) = ppc_menu_list_definition(memory, source) else {
*last_mem_error = PPC_PARAM_ERR;
return Some(PpcImportAction::ReturnPreserve);
};
let mut allocator = PpcProcessAllocatorView {
memory_manager: process_memory_manager,
};
let installation =
install_menu_list_copy(*current_menu_list, &menu_list, |request| match request {
MenuListInstallRequest::Allocate { bytes } => {
let handle = allocator.allocate_handle_with_bytes(
memory,
heap_cursor,
last_mem_error,
handles,
bytes,
);
(handle != 0).then_some(handle).ok_or(PPC_MEM_FULL_ERR)
}
MenuListInstallRequest::Replace { handle, bytes } => {
let result = ppc_replace_menu_bytes_with_allocator(
Some(&mut allocator),
memory,
heap_cursor,
heap_limit,
last_mem_error,
handles,
handle,
bytes,
);
(result == PPC_NO_ERR).then_some(handle).ok_or(result)
}
});
match installation {
Ok(installation) => {
*current_menu_list = installation.handle;
if installation.allocated {
ppc_set_current_menu_list(memory, *current_menu_list);
}
*last_mem_error = PPC_NO_ERR;
}
Err(error) => *last_mem_error = error,
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::GetMenuHandle => {
let params =
crate::menu_manager::evaluate_get_menu_handle_parameters(cpu.gpr[3] as u16 as i16);
Some(PpcImportAction::Return(ppc_get_menu_handle(
memory,
*current_menu_list,
params.menu_id(),
)))
}
PpcImportDispatcherTarget::DrawMenuBar => {
event_queue.take_menu_bar_invalidation();
toolbox_startup.menu_bar_draw_count =
toolbox_startup.menu_bar_draw_count.saturating_add(1);
if crate::menu_manager::evaluate_draw_menu_bar(toolbox_startup.host_menu_bar_hidden) {
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
let _ = ppc_draw_menu_bar_with_colors(
memory,
gworlds,
*current_menu_list,
screen_clut,
MenuColorTable::new(&menu_color_bytes),
);
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::InvalMenuBar => {
event_queue.invalidate_menu_bar();
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::FlashMenuBar => {
let params =
crate::menu_manager::evaluate_flash_menu_bar_parameters(cpu.gpr[3] as u16 as i16);
let requested_menu_id = params.menu_id();
let requested_is_regular = requested_menu_id != 0
&& ppc_regular_menu_contains_id(memory, *current_menu_list, requested_menu_id);
let selected_menu_id = memory.read_u16_be(PPC_THE_MENU_ADDR).unwrap_or(0) as i16;
let selected_root_menu_id =
ppc_root_menu_id_for_selection(memory, *current_menu_list, selected_menu_id);
let target = crate::menu_manager::evaluate_flash_menu_bar_target(
requested_menu_id,
requested_is_regular,
selected_root_menu_id,
);
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
let menu_colors = MenuColorTable::new(&menu_color_bytes);
match target {
crate::menu_manager::FlashMenuBarTarget::Title { highlight_id } => {
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
*current_menu_list,
highlight_id,
screen_clut,
menu_colors,
toolbox_startup.host_menu_bar_hidden,
);
}
crate::menu_manager::FlashMenuBarTarget::EntireBar => {
if !toolbox_startup.host_menu_bar_hidden {
let _ = ppc_flash_entire_menu_bar_with_colors(
memory,
gworlds,
screen_clut,
menu_colors,
);
}
}
}
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::HMGetHelpMenuHandle => {
let params =
crate::menu_manager::evaluate_hm_get_help_menu_handle_parameters(cpu.gpr[3]);
if params.has_output_ptr() {
let _ = memory.write_u32_be(params.out_handle_ptr(), 0);
}
Some(PpcImportAction::Return(ppc_i16_result(
crate::menu_manager::HM_HELP_MANAGER_NOT_INITED_ERR,
)))
}
PpcImportDispatcherTarget::HMGetBalloons => {
Some(PpcImportAction::Return(u32::from(
toolbox_startup.help_balloons_enabled,
)))
}
PpcImportDispatcherTarget::HMSetBalloons => {
let params = crate::menu_manager::evaluate_hm_set_balloons_parameters(cpu.gpr[3]);
toolbox_startup.help_balloons_enabled = params.enabled();
Some(PpcImportAction::Return(ppc_i16_result(PPC_NO_ERR)))
}
PpcImportDispatcherTarget::HMIsBalloon => {
Some(PpcImportAction::Return(u32::from(
crate::menu_manager::evaluate_hm_is_balloon(),
)))
}
PpcImportDispatcherTarget::HiliteMenu => {
let params =
crate::menu_manager::evaluate_hilite_menu_parameters(cpu.gpr[3] as u16 as i16);
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
ppc_set_menu_title_highlight_with_colors(
memory,
gworlds,
*current_menu_list,
params.menu_id(),
screen_clut,
MenuColorTable::new(&menu_color_bytes),
toolbox_startup.host_menu_bar_hidden,
);
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::MenuNoop => Some(PpcImportAction::ReturnPreserve),
PpcImportDispatcherTarget::MenuKey => {
let params = crate::menu_manager::evaluate_menu_key_parameters(cpu.gpr[3]);
let menu_color_bytes = ppc_menu_color_table_bytes(memory, handles);
let menu_colors = MenuColorTable::new(&menu_color_bytes);
let selection = ppc_menu_key(memory, *current_menu_list, params.key_char());
let result = selection.map_or(0, MenuKeySelection::packed_result);
let root_menu_id = selection
.and_then(|selection| selection.owner_handle)
.and_then(|owner_handle| memory.read_u32_be(owner_handle))
.filter(|menu| *menu != 0)
.and_then(|menu| memory.read_u16_be(menu))
.map_or(0, |menu_id| menu_id as i16);
ppc_set_menu_command_highlight_with_colors(
memory,
gworlds,
*current_menu_list,
result,
Some(root_menu_id),
screen_clut,
menu_colors,
toolbox_startup.host_menu_bar_hidden,
);
if crate::trap::dispatch::trace_input_enabled() {
eprintln!(
"[INPUT] PPC MenuKey menu_list=${:08X} key=${:02X} -> ${result:08X}",
*current_menu_list,
params.key_char()
);
}
Some(PpcImportAction::Return(result))
}
PpcImportDispatcherTarget::MenuEvent => {
let result = if let Some(params) =
crate::menu_manager::evaluate_menu_event_parameters(cpu.gpr[3])
{
let event = params.event_ptr();
let what = memory.read_u16_be(event).unwrap_or(0);
let message = memory.read_u32_be(event + 2).unwrap_or(0);
let modifiers = memory.read_u16_be(event + 14).unwrap_or(0);
if let Some(key_char) =
crate::menu_manager::evaluate_menu_event_candidate(what, message, modifiers)
{
ppc_menu_key(memory, *current_menu_list, key_char)
.map_or(0, MenuKeySelection::packed_result)
} else {
0
}
} else {
0
};
Some(PpcImportAction::Return(result))
}
PpcImportDispatcherTarget::MenuChoice => {
let raw_disable = memory
.read_u32_be(crate::memory::globals::addr::MENU_DISABLE)
.unwrap_or(0);
Some(PpcImportAction::Return(
crate::menu_manager::evaluate_menu_choice_result(raw_disable),
))
}
PpcImportDispatcherTarget::GetMBarHeight => {
let height = crate::menu_manager::evaluate_get_mbar_height(
memory.read_u16_be(PPC_MBAR_HEIGHT_ADDR),
);
Some(PpcImportAction::Return(u32::from(height)))
}
PpcImportDispatcherTarget::SetMBarHeight => {
let params = crate::menu_manager::evaluate_set_mbar_height_parameters(
cpu.gpr[3] as u16 as i16,
);
let _ = memory.write_u16_be(PPC_MBAR_HEIGHT_ADDR, params.height() as u16);
Some(PpcImportAction::ReturnPreserve)
}
PpcImportDispatcherTarget::MenuSelect => {
let _params = crate::menu_manager::evaluate_menu_select_parameters(cpu.gpr[3]);
ppc_step_menu_tracking(
cpu,
process_memory_manager,
memory,
heap_cursor,
heap_limit,
gworlds,
screen_clut,
toolbox_startup,
current_gworld,
current_gdevice,
input,
vfs_resources,
current_resource_refnum,
)
}
_ => None,
}
}