use super::*;
use std::collections::BTreeMap;
const PPC_NOT_OPEN_ERR: i16 = -28;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PpcToolboxCompatOperation {
UnopenedDriver,
GetRegionBounds,
GetPortTextFont,
GetPortTextSize,
GetPortTextFace,
GetPortTextMode,
GetPortPenMode,
GetPortPenSize,
GetPortGrafProcs,
GetPortForeColor,
GetPortBackColor,
GetPixBounds,
SetPortBounds,
SetPortGrafProcs,
SetPortPenMode,
IsPortColor,
CommToolboxNil,
CommToolboxError,
}
pub(crate) fn ppc_dispatch_toolbox_compat(
operation: PpcToolboxCompatOperation,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
) -> PpcImportAction {
match operation {
PpcToolboxCompatOperation::UnopenedDriver => {
PpcImportAction::Return(ppc_i16_result(PPC_NOT_OPEN_ERR))
}
PpcToolboxCompatOperation::GetRegionBounds => {
let (region, out) = (cpu.gpr[3], cpu.gpr[4]);
let master = memory.read_u32_be(region).unwrap_or(0);
if master != 0 && ppc_memory_can_write_bytes(memory, out, 8) {
for offset in (0..8).step_by(2) {
let value = memory.read_u16_be(master + 2 + offset).unwrap_or(0);
let _ = memory.write_u16_be(out + offset, value);
}
}
PpcImportAction::Return(out)
}
PpcToolboxCompatOperation::GetPortTextFont | PpcToolboxCompatOperation::GetPortTextSize => {
let offset = if operation == PpcToolboxCompatOperation::GetPortTextFont {
68
} else {
74
};
let value = memory
.read_u16_be(cpu.gpr[3].wrapping_add(offset))
.unwrap_or(0);
PpcImportAction::Return(value as i16 as i32 as u32)
}
PpcToolboxCompatOperation::GetPortTextFace => {
let value = memory.read_u8(cpu.gpr[3].wrapping_add(70)).unwrap_or(0);
PpcImportAction::Return(u32::from(value))
}
PpcToolboxCompatOperation::GetPortTextMode => {
let value = memory.read_u16_be(cpu.gpr[3].wrapping_add(72)).unwrap_or(0);
PpcImportAction::Return(value as i16 as i32 as u32)
}
PpcToolboxCompatOperation::GetPortPenMode => {
let value = memory.read_u16_be(cpu.gpr[3].wrapping_add(56)).unwrap_or(0);
PpcImportAction::Return(value as i16 as i32 as u32)
}
PpcToolboxCompatOperation::GetPortPenSize => {
let (port, out) = (cpu.gpr[3], cpu.gpr[4]);
let size = memory.read_u32_be(port.wrapping_add(52)).unwrap_or(0);
if ppc_memory_can_write_bytes(memory, out, 4) {
let _ = memory.write_u32_be(out, size);
}
PpcImportAction::Return(out)
}
PpcToolboxCompatOperation::GetPortGrafProcs => {
let procs = memory
.read_u32_be(cpu.gpr[3].wrapping_add(104))
.unwrap_or(0);
PpcImportAction::Return(procs)
}
PpcToolboxCompatOperation::GetPortForeColor
| PpcToolboxCompatOperation::GetPortBackColor => {
let (port, out) = (cpu.gpr[3], cpu.gpr[4]);
let fore = operation == PpcToolboxCompatOperation::GetPortForeColor;
let color_port = memory
.read_u16_be(port.wrapping_add(6))
.is_some_and(|version| version & 0xc000 == 0xc000);
let components = if color_port {
let base = port.wrapping_add(if fore { 36 } else { 42 });
[0, 2, 4].map(|offset| memory.read_u16_be(base + offset).unwrap_or(0))
} else if fore {
[0; 3]
} else {
[0xffff; 3]
};
if ppc_memory_can_write_bytes(memory, out, 6) {
for (index, component) in components.into_iter().enumerate() {
let _ = memory.write_u16_be(out + 2 * index as u32, component);
}
}
PpcImportAction::Return(out)
}
PpcToolboxCompatOperation::GetPixBounds => {
let (pixmap, out) = (cpu.gpr[3], cpu.gpr[4]);
let master = memory.read_u32_be(pixmap).unwrap_or(0);
if master != 0 && ppc_memory_can_write_bytes(memory, out, 8) {
for offset in (0..8).step_by(2) {
let value = memory.read_u16_be(master + 6 + offset).unwrap_or(0);
let _ = memory.write_u16_be(out + offset, value);
}
}
PpcImportAction::Return(out)
}
PpcToolboxCompatOperation::CommToolboxNil => PpcImportAction::Return(0),
PpcToolboxCompatOperation::CommToolboxError => PpcImportAction::Return(ppc_i16_result(-1)),
PpcToolboxCompatOperation::SetPortBounds => {
let (port, rect) = (cpu.gpr[3], cpu.gpr[4]);
if let Some((top, left, bottom, right)) = ppc_read_rect(memory, rect) {
if port != 0 && ppc_memory_can_write_bytes(memory, port.wrapping_add(16), 8) {
let _ = ppc_write_rect(memory, port.wrapping_add(16), top, left, bottom, right);
}
}
PpcImportAction::ReturnPreserve
}
PpcToolboxCompatOperation::SetPortGrafProcs => {
let port = cpu.gpr[3];
if port != 0 && ppc_memory_can_write_bytes(memory, port.wrapping_add(104), 4) {
let _ = memory.write_u32_be(port.wrapping_add(104), cpu.gpr[4]);
}
PpcImportAction::ReturnPreserve
}
PpcToolboxCompatOperation::SetPortPenMode => {
let port = cpu.gpr[3];
if port != 0 && ppc_memory_can_write_bytes(memory, port.wrapping_add(56), 2) {
let _ = memory.write_u16_be(port.wrapping_add(56), cpu.gpr[4] as u16);
}
PpcImportAction::ReturnPreserve
}
PpcToolboxCompatOperation::IsPortColor => {
let color = cpu.gpr[3] != 0
&& memory
.read_u16_be(cpu.gpr[3].wrapping_add(6))
.is_some_and(|version| version & 0xc000 == 0xc000);
PpcImportAction::Return(u32::from(color))
}
}
}
const PPC_DEFAULT_WINDOW_CONTENT_COLOR: [u16; 3] = [0xffff; 3];
pub(crate) fn ppc_window_content_color(
set: bool,
cpu: &PpcCpu,
memory: &mut PpcSectionMem,
colors: &mut BTreeMap<u32, [u16; 3]>,
) -> PpcImportAction {
let (window, color) = (cpu.gpr[3], cpu.gpr[4]);
if window == 0 || color == 0 {
return PpcImportAction::Return(ppc_i16_result(PPC_PARAM_ERR));
}
let result = if set {
match ppc_read_rgb_color(memory, color) {
Some(rgb) => {
colors.insert(window, [rgb.red, rgb.green, rgb.blue]);
PPC_NO_ERR
}
None => PPC_PARAM_ERR,
}
} else {
let components = colors
.get(&window)
.copied()
.unwrap_or(PPC_DEFAULT_WINDOW_CONTENT_COLOR);
if ppc_memory_can_write_bytes(memory, color, 6) {
for (index, component) in components.into_iter().enumerate() {
let _ = memory.write_u16_be(color + 2 * index as u32, component);
}
PPC_NO_ERR
} else {
PPC_PARAM_ERR
}
};
PpcImportAction::Return(ppc_i16_result(result))
}