ironrdp-displaycontrol

pub const CHANNEL_NAME: &str = "Microsoft::Windows::RDS::DisplayControl";

pub struct DisplayControlClient {
    on_capabilities_received: OnCapabilitiesReceived,
    ready: bool,
}

impl DisplayControlClient {
    pub fn new<F>(callback: F) -> Self
    where
        F: Fn(DisplayControlCapabilities) -> PduResult<Vec<DvcMessage>> + Send + 'static
}

pub enum DisplayControlPdu {
    Caps(DisplayControlCapabilities),
    MonitorLayout(DisplayControlMonitorLayout),
}

pub struct DisplayControlCapabilities {
    max_num_monitors: u32,
    max_monitor_area_factor_a: u32,
    max_monitor_area_factor_b: u32,
    max_monitor_area: u64,
}

pub struct DisplayControlMonitorLayout {
    monitors: Vec<MonitorLayoutEntry>,
}

pub struct MonitorLayoutEntry {
    is_primary: bool,
    left: i32,
    top: i32,
    width: u32,
    height: u32,
    physical_width: u32,
    physical_height: u32,
    orientation: u32,
    desktop_scale_factor: u32,
    device_scale_factor: u32,
}

use ironrdp::displaycontrol::client::DisplayControlClient;
use ironrdp::displaycontrol::pdu::DisplayControlCapabilities;

// Create display control client with capabilities callback
let display_client = DisplayControlClient::new(|caps| {
    println!("Server capabilities:");
    println!("  Max monitors: {}", caps.max_num_monitors());
    println!("  Max area: {}", caps.max_monitor_area());
    Ok(Vec::new())
});

// Add to DVC processor
dvc_processor.add_dynamic_channel(display_client);

use ironrdp::displaycontrol::pdu::MonitorLayoutEntry;

// Wait for channel to be ready
if !display_client.ready() {
    return Err("Display control channel not ready");
}

// Adjust display size to valid range
let (width, height) = MonitorLayoutEntry::adjust_display_size(1920, 1080);

// Create single monitor layout
let messages = display_client.encode_single_primary_monitor(
    channel_id,
    width,
    height,
    Some(100), // 100% scale factor
    None,      // No physical dimensions
)?;

// Send to server
for message in messages {
    send_svc_message(message)?;
}

use ironrdp::displaycontrol::pdu::{
    DisplayControlMonitorLayout,
    MonitorLayoutEntry,
    MonitorOrientation,
};

// Create primary monitor
let primary = MonitorLayoutEntry::new_primary(1920, 1080)?
    .with_orientation(MonitorOrientation::Landscape);

// Create secondary monitor
let secondary = MonitorLayoutEntry::new_secondary(1920, 1080)?
    .with_position(1920, 0)?  // Position to the right of primary
    .with_orientation(MonitorOrientation::Landscape);

// Build layout
let layout = DisplayControlMonitorLayout::new(&[primary, secondary])?;

// Encode and send
let pdu: DisplayControlPdu = layout.into();
let messages = encode_dvc_messages(channel_id, vec![Box::new(pdu)], ChannelFlags::empty())?;
send_messages(messages)?;

pub enum MonitorOrientation {
    Landscape,         // 0 degrees
    Portrait,          // 90 degrees
    LandscapeFlipped,  // 180 degrees
    PortraitFlipped,   // 270 degrees
}

pub enum DeviceScaleFactor {
    Scale100Percent,  // 100%
    Scale140Percent,  // 140%
    Scale180Percent,  // 180%
}

pub fn adjust_display_size(width: u32, height: u32) -> (u32, u32) {
    let constrain = |value: u32| value.clamp(200, 8192);
    
    let mut width = width;
    if width % 2 != 0 {
        width = width.saturating_sub(1);
    }
    
    (constrain(width), constrain(height))
}