pub const CURSOR_RECORD_SIZE: usize = 68;
pub const CURSOR_DATA_OFFSET: usize = 0;
pub const CURSOR_MASK_OFFSET: usize = 32;
pub const CURSOR_HOT_V_OFFSET: usize = 64;
pub const CURSOR_HOT_H_OFFSET: usize = 66;
pub const CURSOR_BITMAP_SIZE: usize = 32;
pub const CURSOR_WIDTH: i16 = 16;
pub const CURSOR_HEIGHT: i16 = 16;
#[allow(dead_code)]
pub const IBEAM_CURSOR_ID: i16 = 1;
#[allow(dead_code)]
pub const CROSS_CURSOR_ID: i16 = 2;
#[allow(dead_code)]
pub const PLUS_CURSOR_ID: i16 = 3;
#[allow(dead_code)]
pub const WATCH_CURSOR_ID: i16 = 4;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InitCursorAction;
#[inline]
pub fn evaluate_init_cursor() -> InitCursorAction {
InitCursorAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HideCursorAction;
#[inline]
pub fn evaluate_hide_cursor() -> HideCursorAction {
HideCursorAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ShowCursorAction;
#[inline]
pub fn evaluate_show_cursor() -> ShowCursorAction {
ShowCursorAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ObscureCursorAction;
#[inline]
pub fn evaluate_obscure_cursor() -> ObscureCursorAction {
ObscureCursorAction
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SetCursorParameters {
pub cursor_ptr: u32,
}
#[inline]
pub fn evaluate_set_cursor_parameters(cursor_ptr: u32) -> SetCursorParameters {
SetCursorParameters { cursor_ptr }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ShieldCursorParameters {
pub rect_ptr: u32,
pub offset_v: i16,
pub offset_h: i16,
}
#[inline]
pub fn evaluate_shield_cursor_parameters(
rect_ptr: u32,
offset_v: i16,
offset_h: i16,
) -> ShieldCursorParameters {
ShieldCursorParameters {
rect_ptr,
offset_v,
offset_h,
}
}
#[inline]
pub fn evaluate_cursor_shield_overlap(
shield_rect: (i16, i16, i16, i16),
offset: (i16, i16),
mouse_pos: (i16, i16),
hot_spot: (i16, i16),
) -> bool {
let shield_top = shield_rect.0.wrapping_add(offset.0);
let shield_left = shield_rect.1.wrapping_add(offset.1);
let shield_bottom = shield_rect.2.wrapping_add(offset.0);
let shield_right = shield_rect.3.wrapping_add(offset.1);
let cursor_top = mouse_pos.0.saturating_sub(hot_spot.0);
let cursor_left = mouse_pos.1.saturating_sub(hot_spot.1);
let cursor_bottom = cursor_top.saturating_add(CURSOR_HEIGHT);
let cursor_right = cursor_left.saturating_add(CURSOR_WIDTH);
cursor_top < shield_bottom
&& cursor_bottom > shield_top
&& cursor_left < shield_right
&& cursor_right > shield_left
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GetCursorParameters {
pub cursor_id: i16,
}
#[inline]
pub fn evaluate_get_cursor_parameters(cursor_id: i16) -> GetCursorParameters {
GetCursorParameters { cursor_id }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GetCCursorParameters {
pub cursor_id: i16,
}
#[inline]
pub fn evaluate_get_ccursor_parameters(cursor_id: i16) -> GetCCursorParameters {
GetCCursorParameters { cursor_id }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SetCCursorParameters {
pub cursor_handle: u32,
}
#[inline]
pub fn evaluate_set_ccursor_parameters(cursor_handle: u32) -> SetCCursorParameters {
SetCCursorParameters { cursor_handle }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DisposeCCursorParameters {
pub cursor_handle: u32,
}
#[inline]
pub fn evaluate_dispose_ccursor_parameters(cursor_handle: u32) -> DisposeCCursorParameters {
DisposeCCursorParameters { cursor_handle }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GetCIconParameters {
pub icon_id: i16,
}
#[inline]
pub fn evaluate_get_cicon_parameters(icon_id: i16) -> GetCIconParameters {
GetCIconParameters { icon_id }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PlotCIconParameters {
pub rect_ptr: u32,
pub cicon_handle: u32,
}
#[inline]
pub fn evaluate_plot_cicon_parameters(rect_ptr: u32, cicon_handle: u32) -> PlotCIconParameters {
PlotCIconParameters {
rect_ptr,
cicon_handle,
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DisposeCIconParameters {
pub cicon_handle: u32,
}
#[inline]
pub fn evaluate_dispose_cicon_parameters(cicon_handle: u32) -> DisposeCIconParameters {
DisposeCIconParameters { cicon_handle }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct GetQDGlobalsArrowParameters {
pub destination_ptr: u32,
}
#[inline]
pub fn evaluate_get_qd_globals_arrow_parameters(
destination_ptr: u32,
) -> GetQDGlobalsArrowParameters {
GetQDGlobalsArrowParameters { destination_ptr }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CrsrDevNextDeviceParameters {
pub device_ptr: u32,
}
#[inline]
pub fn evaluate_crsr_dev_next_device_parameters(device_ptr: u32) -> CrsrDevNextDeviceParameters {
CrsrDevNextDeviceParameters { device_ptr }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CrsrDevMoveToParameters {
pub device_ptr: u32,
pub x: i32,
pub y: i32,
}
#[inline]
pub fn evaluate_crsr_dev_move_to_parameters(
device_ptr: u32,
x: i32,
y: i32,
) -> CrsrDevMoveToParameters {
CrsrDevMoveToParameters { device_ptr, x, y }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cursor_and_icon_manager_evaluation() {
assert_eq!(CURSOR_RECORD_SIZE, 68);
assert_eq!(CURSOR_DATA_OFFSET, 0);
assert_eq!(CURSOR_MASK_OFFSET, 32);
assert_eq!(CURSOR_HOT_V_OFFSET, 64);
assert_eq!(CURSOR_HOT_H_OFFSET, 66);
assert_eq!(CURSOR_BITMAP_SIZE, 32);
assert_eq!(CURSOR_WIDTH, 16);
assert_eq!(CURSOR_HEIGHT, 16);
assert_eq!(IBEAM_CURSOR_ID, 1);
assert_eq!(CROSS_CURSOR_ID, 2);
assert_eq!(PLUS_CURSOR_ID, 3);
assert_eq!(WATCH_CURSOR_ID, 4);
assert_eq!(evaluate_init_cursor(), InitCursorAction);
assert_eq!(evaluate_hide_cursor(), HideCursorAction);
assert_eq!(evaluate_show_cursor(), ShowCursorAction);
assert_eq!(evaluate_obscure_cursor(), ObscureCursorAction);
let set_cursor = evaluate_set_cursor_parameters(0x1234_5678);
assert_eq!(set_cursor.cursor_ptr, 0x1234_5678);
let shield_params = evaluate_shield_cursor_parameters(0x2000, 10, 20);
assert_eq!(shield_params.rect_ptr, 0x2000);
assert_eq!(shield_params.offset_v, 10);
assert_eq!(shield_params.offset_h, 20);
assert!(evaluate_cursor_shield_overlap(
(50, 50, 100, 100),
(0, 0),
(60, 60),
(0, 0)
));
assert!(!evaluate_cursor_shield_overlap(
(50, 50, 100, 100),
(0, 0),
(200, 200),
(0, 0)
));
assert!(evaluate_cursor_shield_overlap(
(0, 0, 50, 50),
(100, 100),
(120, 120),
(0, 0)
));
let get_cursor = evaluate_get_cursor_parameters(4);
assert_eq!(get_cursor.cursor_id, 4);
let get_ccursor = evaluate_get_ccursor_parameters(128);
assert_eq!(get_ccursor.cursor_id, 128);
let set_ccursor = evaluate_set_ccursor_parameters(0x8000_1000);
assert_eq!(set_ccursor.cursor_handle, 0x8000_1000);
let dispose_ccursor = evaluate_dispose_ccursor_parameters(0x8000_1000);
assert_eq!(dispose_ccursor.cursor_handle, 0x8000_1000);
let get_cicon = evaluate_get_cicon_parameters(256);
assert_eq!(get_cicon.icon_id, 256);
let plot_cicon = evaluate_plot_cicon_parameters(0x3000, 0x8000_2000);
assert_eq!(plot_cicon.rect_ptr, 0x3000);
assert_eq!(plot_cicon.cicon_handle, 0x8000_2000);
let dispose_cicon = evaluate_dispose_cicon_parameters(0x8000_2000);
assert_eq!(dispose_cicon.cicon_handle, 0x8000_2000);
let qd_arrow = evaluate_get_qd_globals_arrow_parameters(0x4000);
assert_eq!(qd_arrow.destination_ptr, 0x4000);
let next_dev = evaluate_crsr_dev_next_device_parameters(0x5000);
assert_eq!(next_dev.device_ptr, 0x5000);
let move_to = evaluate_crsr_dev_move_to_parameters(0x5000, 100, 200);
assert_eq!(move_to.device_ptr, 0x5000);
assert_eq!(move_to.x, 100);
assert_eq!(move_to.y, 200);
}
}
pub(crate) const CURSOR_DEVICE_SIZE: usize = 138;
pub(crate) const CURSOR_DATA_SIZE: usize = 70;
pub(crate) const CURSOR_DATA_STORAGE_OFFSET: u32 = ((CURSOR_DEVICE_SIZE + 3) & !3) as u32;
pub(crate) const CURSOR_DEVICE_STORAGE_SIZE: u32 =
CURSOR_DATA_STORAGE_OFFSET + CURSOR_DATA_SIZE as u32;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct CursorDeviceRecords {
pub(crate) device: u32,
pub(crate) data: u32,
}
impl CursorDeviceRecords {
pub(crate) fn from_storage(device: u32) -> Option<Self> {
if device == 0 {
return None;
}
device.checked_add(CURSOR_DEVICE_STORAGE_SIZE)?;
Some(Self {
device,
data: device + CURSOR_DATA_STORAGE_OFFSET,
})
}
pub(crate) fn initial_storage(self, position: (i16, i16), pressed: bool) -> Vec<u8> {
let mut bytes = vec![0; CURSOR_DEVICE_STORAGE_SIZE as usize];
bytes[4..8].copy_from_slice(&self.data.to_be_bytes());
bytes[20..24].copy_from_slice(&(72u32 << 16).to_be_bytes());
bytes[24] = 1; bytes[25] = 1;
bytes[27] = u8::from(pressed);
bytes[100..104].copy_from_slice(&30u32.to_be_bytes());
bytes[104..108].copy_from_slice(&(1u32 << 16).to_be_bytes());
let data = &mut bytes[CURSOR_DATA_STORAGE_OFFSET as usize..];
data[8..20].copy_from_slice(&cursor_device_position_bytes(position));
data[20] = 1;
data[21] = u8::from(pressed);
data[22..26].copy_from_slice(&72u32.to_be_bytes());
bytes
}
}
pub(crate) fn cursor_device_position_bytes((v, h): (i16, i16)) -> [u8; 12] {
let mut bytes = [0; 12];
bytes[..4].copy_from_slice(&((h as i32) << 16).to_be_bytes());
bytes[4..8].copy_from_slice(&((v as i32) << 16).to_be_bytes());
bytes[8..10].copy_from_slice(&v.to_be_bytes());
bytes[10..12].copy_from_slice(&h.to_be_bytes());
bytes
}
pub(crate) fn sync_classic_cursor_device(
bus: &mut crate::memory::MacMemoryBus,
input: &crate::process_context::SharedProcessInputState,
) {
use crate::memory::MemoryBus;
if let Some(records) = input.cursor_device_records() {
let (position, pressed) = input.mouse_state_snapshot();
if bus.is_guest_address_writable(records.data + 8, 14)
&& bus.is_guest_address_writable(records.device + 27, 1)
{
bus.write_bytes(records.data + 8, &cursor_device_position_bytes(position));
bus.write_byte(records.data + 21, u8::from(pressed));
bus.write_byte(records.device + 27, u8::from(pressed));
}
}
}