pub(crate) fn standard_button_tracking_start_point(
rect: (i16, i16, i16, i16),
start: (i16, i16),
live_global: (i16, i16),
owner_origin: (i16, i16),
button_down: bool,
proc_id: i16,
) -> (i16, i16) {
if !matches!(proc_id & 0x0fff, 0 | 1 | 2) {
return start;
}
live_control_tracking_start_point(rect, start, live_global, owner_origin, button_down)
}
pub(crate) fn live_control_tracking_start_point(
rect: (i16, i16, i16, i16),
start: (i16, i16),
live_global: (i16, i16),
owner_origin: (i16, i16),
button_down: bool,
) -> (i16, i16) {
let inside = |(v, h): (i16, i16)| v >= rect.0 && v < rect.2 && h >= rect.1 && h < rect.3;
if inside(start) || !button_down || start != live_global {
return start;
}
let local = (
live_global.0.wrapping_sub(owner_origin.0),
live_global.1.wrapping_sub(owner_origin.1),
);
if inside(local) {
local
} else {
start
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct ProcessControlProperty {
pub(crate) creator: u32,
pub(crate) tag: u32,
pub(crate) attributes: u32,
pub(crate) data: Vec<u8>,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct ProcessControlRecord {
pub(crate) handle: u32,
pub(crate) pointer: u32,
pub(crate) proc_id: i16,
pub(crate) popup_menu_id: i16,
pub(crate) popup_title_width: Option<i16>,
pub(crate) active: bool,
pub(crate) font_style: Option<ControlFontStyle>,
pub(crate) is_root: bool,
pub(crate) parent: u32,
pub(crate) sub_controls: Vec<u32>,
pub(crate) properties: Vec<ProcessControlProperty>,
pub(crate) color_proc: u32,
pub(crate) control_id: (u32, i32),
pub(crate) command_id: u32,
pub(crate) has_focus: bool,
pub(crate) focus_part: i16,
pub(crate) drag_tracking_enabled: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct ControlFontStyle {
pub(crate) flags: i16,
pub(crate) font: i16,
pub(crate) size: i16,
pub(crate) style: i16,
pub(crate) mode: i16,
pub(crate) justification: i16,
pub(crate) foreground: [u16; 3],
pub(crate) background: [u16; 3],
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct ProcessControlManagerState {
records: Vec<ProcessControlRecord>,
}
impl ProcessControlManagerState {
pub(crate) fn is_pristine(&self) -> bool {
self.records.is_empty()
}
pub(crate) fn register(&mut self, handle: u32, pointer: u32, proc_id: i16, popup_menu_id: i16) {
self.records
.retain(|record| handle == 0 || record.handle != handle || record.pointer == pointer);
if let Some(record) = self
.records
.iter_mut()
.find(|record| record.pointer == pointer && pointer != 0)
{
if handle != 0 {
record.handle = handle;
}
record.proc_id = proc_id;
record.popup_menu_id = popup_menu_id;
return;
}
self.records.push(ProcessControlRecord {
handle,
pointer,
proc_id,
popup_menu_id,
popup_title_width: None,
active: true,
font_style: None,
is_root: false,
parent: 0,
sub_controls: Vec::new(),
properties: Vec::new(),
color_proc: 0,
control_id: (0, 0),
command_id: 0,
has_focus: false,
focus_part: 0,
drag_tracking_enabled: false,
});
}
#[allow(dead_code)]
pub(crate) fn color_proc(&self, handle: u32) -> u32 {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or(0, |record| record.color_proc)
}
#[allow(dead_code)]
pub(crate) fn set_color_proc(&mut self, handle: u32, proc: u32) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.color_proc = proc;
}
}
#[allow(dead_code)]
pub(crate) fn control_id(&self, handle: u32) -> (u32, i32) {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or((0, 0), |record| record.control_id)
}
#[allow(dead_code)]
pub(crate) fn set_control_id(&mut self, handle: u32, signature: u32, id: i32) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.control_id = (signature, id);
}
}
#[allow(dead_code)]
pub(crate) fn command_id(&self, handle: u32) -> u32 {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or(0, |record| record.command_id)
}
#[allow(dead_code)]
pub(crate) fn set_command_id(&mut self, handle: u32, command_id: u32) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.command_id = command_id;
}
}
#[allow(dead_code)]
pub(crate) fn has_focus(&self, handle: u32) -> bool {
self.records
.iter()
.find(|record| record.handle == handle)
.is_some_and(|record| record.has_focus)
}
#[allow(dead_code)]
pub(crate) fn set_has_focus(&mut self, handle: u32, focus: bool) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.has_focus = focus;
}
}
#[allow(dead_code)]
pub(crate) fn focus_part(&self, handle: u32) -> i16 {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or(0, |record| record.focus_part)
}
#[allow(dead_code)]
pub(crate) fn set_focus_part(&mut self, handle: u32, part: i16) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.focus_part = part;
record.has_focus = part != 0;
}
}
#[allow(dead_code)]
pub(crate) fn drag_tracking_enabled(&self, handle: u32) -> bool {
self.records
.iter()
.find(|record| record.handle == handle)
.is_some_and(|record| record.drag_tracking_enabled)
}
#[allow(dead_code)]
pub(crate) fn set_drag_tracking_enabled(&mut self, handle: u32, enabled: bool) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.drag_tracking_enabled = enabled;
}
}
pub(crate) fn proc_id(&self, pointer: u32) -> i16 {
self.records
.iter()
.find(|record| record.pointer == pointer)
.map_or(0, |record| record.proc_id)
}
pub(crate) fn contains_pointer(&self, pointer: u32) -> bool {
self.records.iter().any(|record| record.pointer == pointer)
}
pub(crate) fn set_font_style(&mut self, pointer: u32, style: Option<ControlFontStyle>) {
if let Some(record) = self.records.iter_mut().find(|record| record.pointer == pointer) {
record.font_style = style;
}
}
pub(crate) fn set_proc_id(&mut self, pointer: u32, proc_id: i16) {
if let Some(record) = self
.records
.iter_mut()
.find(|record| record.pointer == pointer)
{
record.proc_id = proc_id;
} else {
self.register(0, pointer, proc_id, 0);
}
}
pub(crate) fn associate_handle(&mut self, handle: u32, pointer: u32) {
self.records
.retain(|record| record.handle != handle || record.pointer == pointer);
if let Some(record) = self
.records
.iter_mut()
.find(|record| record.pointer == pointer)
{
record.handle = handle;
} else {
self.register(handle, pointer, 0, 0);
}
}
pub(crate) fn set_popup_title_width(&mut self, pointer: u32, width: i16) {
if !self.records.iter().any(|record| record.pointer == pointer) {
self.register(0, pointer, 0, 0);
}
if let Some(record) = self
.records
.iter_mut()
.find(|record| record.pointer == pointer)
{
record.popup_title_width = Some(width);
}
}
pub(crate) fn popup_title_width(&self, pointer: u32, fallback: i16) -> i16 {
self.records
.iter()
.find(|record| record.pointer == pointer)
.and_then(|record| record.popup_title_width)
.unwrap_or(fallback)
}
pub(crate) fn remove_pointer(&mut self, pointer: u32) {
let handle = self
.records
.iter()
.find(|record| record.pointer == pointer)
.map_or(0, |record| record.handle);
if handle != 0 {
self.remove_handle(handle);
} else {
self.records.retain(|record| record.pointer != pointer);
}
}
pub(crate) fn remove_handle(&mut self, handle: u32) {
let parent = self.parent(handle);
if parent != 0 {
if let Some(parent_rec) = self.records.iter_mut().find(|r| r.handle == parent) {
parent_rec.sub_controls.retain(|h| *h != handle);
}
}
for record in self.records.iter_mut() {
if record.parent == handle {
record.parent = 0;
}
record.sub_controls.retain(|h| *h != handle);
}
self.records.retain(|record| record.handle != handle);
}
#[allow(dead_code)]
pub(crate) fn is_root(&self, handle: u32) -> bool {
self.records
.iter()
.find(|record| record.handle == handle)
.is_some_and(|record| record.is_root)
}
#[allow(dead_code)]
pub(crate) fn set_is_root(&mut self, handle: u32, is_root: bool) {
if let Some(record) = self.records.iter_mut().find(|record| record.handle == handle) {
record.is_root = is_root;
}
}
pub(crate) fn parent(&self, handle: u32) -> u32 {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or(0, |record| record.parent)
}
#[allow(dead_code)]
pub(crate) fn count_sub_controls(&self, handle: u32) -> u16 {
self.records
.iter()
.find(|record| record.handle == handle)
.map_or(0, |record| record.sub_controls.len() as u16)
}
#[allow(dead_code)]
pub(crate) fn indexed_sub_control(&self, handle: u32, index: u16) -> Option<u32> {
if index == 0 {
return None;
}
self.records
.iter()
.find(|record| record.handle == handle)
.and_then(|record| record.sub_controls.get((index - 1) as usize).copied())
}
#[allow(dead_code)]
pub(crate) fn embed_control(&mut self, control: u32, container: u32) -> Result<(), i16> {
if control == 0 {
return Err(-30582);
}
if control == container {
return Err(-30594);
}
let mut curr = container;
while curr != 0 {
if curr == control {
return Err(-30594);
}
curr = self.parent(curr);
}
let old_parent = self.parent(control);
if old_parent != 0 {
if let Some(old_rec) = self.records.iter_mut().find(|r| r.handle == old_parent) {
old_rec.sub_controls.retain(|h| *h != control);
}
}
if let Some(rec) = self.records.iter_mut().find(|r| r.handle == control) {
rec.parent = container;
} else {
self.records.push(ProcessControlRecord {
handle: control,
parent: container,
..Default::default()
});
}
if container != 0 {
if let Some(container_rec) = self.records.iter_mut().find(|r| r.handle == container) {
if !container_rec.sub_controls.contains(&control) {
container_rec.sub_controls.push(control);
}
} else {
self.records.push(ProcessControlRecord {
handle: container,
sub_controls: vec![control],
..Default::default()
});
}
}
Ok(())
}
#[allow(dead_code)]
pub(crate) fn set_property(
&mut self,
control: u32,
creator: u32,
tag: u32,
attributes: u32,
data: Vec<u8>,
) {
if control == 0 {
return;
}
let record = if let Some(rec) = self.records.iter_mut().find(|r| r.handle == control) {
rec
} else {
self.records.push(ProcessControlRecord {
handle: control,
..Default::default()
});
self.records.last_mut().unwrap()
};
if let Some(prop) = record
.properties
.iter_mut()
.find(|p| p.creator == creator && p.tag == tag)
{
prop.attributes = attributes;
prop.data = data;
} else {
record.properties.push(ProcessControlProperty {
creator,
tag,
attributes,
data,
});
}
}
#[allow(dead_code)]
pub(crate) fn get_property(
&self,
control: u32,
creator: u32,
tag: u32,
) -> Option<&ProcessControlProperty> {
self.records
.iter()
.find(|r| r.handle == control)
.and_then(|r| r.properties.iter().find(|p| p.creator == creator && p.tag == tag))
}
#[allow(dead_code)]
pub(crate) fn remove_property(&mut self, control: u32, creator: u32, tag: u32) -> bool {
if let Some(rec) = self.records.iter_mut().find(|r| r.handle == control) {
let before = rec.properties.len();
rec.properties.retain(|p| !(p.creator == creator && p.tag == tag));
rec.properties.len() < before
} else {
false
}
}
#[allow(dead_code)]
pub(crate) fn change_property_attributes(
&mut self,
control: u32,
creator: u32,
tag: u32,
set: u32,
clear: u32,
) -> Result<u32, i16> {
if let Some(rec) = self.records.iter_mut().find(|r| r.handle == control) {
if let Some(prop) = rec
.properties
.iter_mut()
.find(|p| p.creator == creator && p.tag == tag)
{
prop.attributes = (prop.attributes | set) & !clear;
return Ok(prop.attributes);
}
}
Err(-5604)
}
#[allow(dead_code)]
pub(crate) fn set_control_data(
&mut self,
control: u32,
_part: i16,
tag: u32,
data: Vec<u8>,
) {
if control == 0 {
return;
}
let record = if let Some(rec) = self.records.iter_mut().find(|r| r.handle == control) {
rec
} else {
self.records.push(ProcessControlRecord {
handle: control,
..Default::default()
});
self.records.last_mut().unwrap()
};
if let Some(prop) = record.properties.iter_mut().find(|p| p.tag == tag) {
prop.data = data;
} else {
record.properties.push(ProcessControlProperty {
creator: 0,
tag,
attributes: 0,
data,
});
}
}
#[allow(dead_code)]
pub(crate) fn get_control_data(
&self,
control: u32,
_part: i16,
tag: u32,
) -> Option<&[u8]> {
self.records
.iter()
.find(|r| r.handle == control)
.and_then(|r| {
r.properties
.iter()
.find(|p| p.creator == 0 && p.tag == tag)
.or_else(|| r.properties.iter().find(|p| p.tag == tag))
})
.map(|p| p.data.as_slice())
}
#[allow(dead_code)]
pub(crate) fn get_control_data_size(
&self,
control: u32,
part: i16,
tag: u32,
) -> Option<usize> {
self.get_control_data(control, part, tag).map(|d| d.len())
}
}
impl std::ops::Deref for ProcessControlManagerState {
type Target = Vec<ProcessControlRecord>;
fn deref(&self) -> &Self::Target {
&self.records
}
}
impl std::ops::DerefMut for ProcessControlManagerState {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.records
}
}
const MAX_CONTROL_LIST_ENTRIES: usize = 4096;
pub(crate) const STANDARD_BUTTON_OVAL: i16 = 10;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct CheckboxLayout {
pub(crate) indicator: (i16, i16, i16, i16),
pub(crate) label_left: i16,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RadioButtonLayout {
pub(crate) indicator: (i16, i16, i16, i16),
pub(crate) label_left: i16,
}
pub(crate) fn standard_checkbox_layout(
(top, left, bottom, _right): (i16, i16, i16, i16),
) -> CheckboxLayout {
let indicator_size = 12.min(bottom.saturating_sub(top).max(1));
let indicator_top =
top.saturating_add(bottom.saturating_sub(top).saturating_sub(indicator_size) / 2);
let indicator_left = left.saturating_add(2);
CheckboxLayout {
indicator: (
indicator_top,
indicator_left,
indicator_top.saturating_add(indicator_size),
indicator_left.saturating_add(indicator_size),
),
label_left: indicator_left
.saturating_add(indicator_size)
.saturating_add(4),
}
}
pub(crate) fn standard_radio_button_layout(
(top, left, bottom, _right): (i16, i16, i16, i16),
) -> RadioButtonLayout {
let indicator_size = 12.min(bottom.saturating_sub(top).max(1));
let indicator_top =
top.saturating_add(bottom.saturating_sub(top).saturating_sub(indicator_size) / 2);
let indicator_left = left.saturating_add(2);
RadioButtonLayout {
indicator: (
indicator_top,
indicator_left,
indicator_top.saturating_add(indicator_size),
indicator_left.saturating_add(indicator_size),
),
label_left: indicator_left
.saturating_add(indicator_size)
.saturating_add(4),
}
}
pub(crate) fn for_each_standard_checkbox_mark_pixel(
size: i16,
mut visit: impl FnMut(i16, i16),
) {
for offset in 1..size.saturating_sub(1) {
visit(offset, offset);
visit(size.saturating_sub(1).saturating_sub(offset), offset);
}
}
pub(crate) fn centered_control_label_origin(
(top, left, bottom, right): (i16, i16, i16, i16),
text_advance: i16,
ascent: i16,
descent: i16,
) -> (i16, i16) {
(
left.saturating_add(right.saturating_sub(left).saturating_sub(text_advance) / 2),
top.saturating_add(
bottom
.saturating_sub(top)
.saturating_sub(ascent.saturating_add(descent))
/ 2,
)
.saturating_add(ascent),
)
}
pub(crate) fn control_draw_order<Handle>(
head: Handle,
mut next: impl FnMut(Handle) -> Option<Handle>,
) -> Vec<Handle>
where
Handle: Copy + Eq + Default,
{
let nil = Handle::default();
let mut newest_first = Vec::new();
let mut handle = head;
while handle != nil
&& newest_first.len() < MAX_CONTROL_LIST_ENTRIES
&& !newest_first.contains(&handle)
{
newest_first.push(handle);
handle = next(handle).unwrap_or(nil);
}
newest_first
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
#[test]
fn draw_order_preserves_the_newest_first_guest_chain() {
let next = HashMap::from([(3u32, 2u32), (2, 1), (1, 0)]);
assert_eq!(
control_draw_order(3, |handle| next.get(&handle).copied()),
[3, 2, 1]
);
}
#[test]
fn draw_order_stops_at_a_corrupt_cycle() {
let next = HashMap::from([(3u32, 2u32), (2, 3)]);
assert_eq!(
control_draw_order(3, |handle| next.get(&handle).copied()),
[3, 2]
);
}
#[test]
fn standard_checkbox_layout_is_shared_guest_geometry() {
assert_eq!(
standard_checkbox_layout((255, 185, 279, 315)),
CheckboxLayout {
indicator: (261, 187, 273, 199),
label_left: 203,
}
);
}
#[test]
fn standard_checkbox_mark_is_the_two_interior_diagonals() {
let mut pixels = Vec::new();
for_each_standard_checkbox_mark_pixel(5, |x, y| pixels.push((x, y)));
assert_eq!(pixels, [(1, 1), (3, 1), (2, 2), (2, 2), (3, 3), (1, 3)]);
}
#[test]
fn standard_radio_button_layout_is_shared_guest_geometry() {
assert_eq!(
standard_radio_button_layout((70, 250, 90, 390)),
RadioButtonLayout {
indicator: (74, 252, 86, 264),
label_left: 268,
}
);
}
#[test]
fn process_control_manager_state_evaluates_embedding_hierarchy() {
let mut state = ProcessControlManagerState::default();
state.register(10, 0x1000, 0, 0);
state.register(20, 0x2000, 0, 0);
state.register(30, 0x3000, 0, 0);
state.set_is_root(10, true);
assert!(state.is_root(10));
assert!(!state.is_root(20));
assert_eq!(state.count_sub_controls(10), 0);
assert_eq!(state.embed_control(20, 10), Ok(()));
assert_eq!(state.embed_control(30, 10), Ok(()));
assert_eq!(state.embed_control(20, 20), Err(-30594));
assert_eq!(state.count_sub_controls(10), 2);
assert_eq!(state.indexed_sub_control(10, 1), Some(20));
assert_eq!(state.indexed_sub_control(10, 2), Some(30));
assert_eq!(state.indexed_sub_control(10, 3), None);
assert_eq!(state.parent(20), 10);
assert_eq!(state.parent(10), 0);
state.remove_handle(20);
assert_eq!(state.count_sub_controls(10), 1);
assert_eq!(state.indexed_sub_control(10, 1), Some(30));
}
#[test]
fn process_control_manager_state_evaluates_tagged_properties() {
let mut state = ProcessControlManagerState::default();
state.register(10, 0x1000, 0, 0);
let creator = 0x5445_5354;
let tag = 0x5441_4731;
state.set_property(10, creator, tag, 0x01, vec![1, 2, 3]);
let prop = state.get_property(10, creator, tag).unwrap();
assert_eq!(prop.creator, creator);
assert_eq!(prop.tag, tag);
assert_eq!(prop.attributes, 0x01);
assert_eq!(prop.data, vec![1, 2, 3]);
assert_eq!(
state.change_property_attributes(10, creator, tag, 0x10, 0x01),
Ok(0x10)
);
let prop = state.get_property(10, creator, tag).unwrap();
assert_eq!(prop.attributes, 0x10);
assert!(state.remove_property(10, creator, tag));
assert!(state.get_property(10, creator, tag).is_none());
assert!(!state.remove_property(10, creator, tag));
}
#[test]
fn process_control_manager_state_evaluates_focus_part_and_drag_tracking() {
let mut state = ProcessControlManagerState::default();
state.register(10, 0x1000, 0, 0);
assert_eq!(state.focus_part(10), 0);
assert!(!state.has_focus(10));
assert!(!state.drag_tracking_enabled(10));
state.set_focus_part(10, 1);
assert_eq!(state.focus_part(10), 1);
assert!(state.has_focus(10));
state.set_focus_part(10, 0);
assert_eq!(state.focus_part(10), 0);
assert!(!state.has_focus(10));
state.set_drag_tracking_enabled(10, true);
assert!(state.drag_tracking_enabled(10));
}
}
#[cfg(test)]
#[test]
fn track_control_start_point_fallback_requires_live_standard_button() {
let rect = (20, 20, 40, 80);
let choose = |start, live, down, proc| {
standard_button_tracking_start_point(rect, start, live, (100, 80), down, proc)
};
assert_eq!(choose((130, 110), (130, 110), true, 0), (30, 30));
assert_eq!(choose((30, 30), (130, 110), true, 0), (30, 30));
assert_eq!(choose((130, 110), (130, 110), false, 0), (130, 110));
assert_eq!(choose((130, 111), (130, 110), true, 0), (130, 111));
assert_eq!(choose((110, 90), (110, 90), true, 0), (110, 90));
for proc in [16, 1008, -1] {
assert_eq!(choose((130, 110), (130, 110), true, proc), (130, 110));
}
}