Struct WindowChanged

pub struct WindowChanged {
    pub window: WindowId,
    pub state: Option<WindowStateAll>,
    pub position: Option<(PxPoint, DipPoint)>,
    pub monitor: Option<MonitorId>,
    pub size: Option<DipSize>,
    pub safe_padding: Option<DipSideOffsets>,
    pub frame_wait_id: Option<FrameWaitId>,
    pub cause: EventCause,
}

Event::WindowChanged payload.

Fields

window: WindowId

Window that has changed state.

state: Option<WindowStateAll>

Window new state, is None if the window state did not change.

position: Option<(PxPoint, DipPoint)>

Window new global position, is None if the window position did not change.

The values are the global position and the position in the monitor.

monitor: Option<MonitorId>

Window new monitor.

The window’s monitor change when it is moved enough so that most of the client area is in the new monitor screen.

size: Option<DipSize>

The window new size, is None if the window size did not change.

safe_padding: Option<DipSideOffsets>

The window new safe padding, is None if the did not change.

frame_wait_id: Option<FrameWaitId>

If the view-process is blocking the event loop for a time waiting for a frame for the new size this ID must be send with the frame to signal that it is the frame for the new size.

Event loop implementations can use this to resize without visible artifacts like the clear color flashing on the window corners, there is a timeout to this delay but it can be a noticeable stutter, a render or render_update request for the window unblocks the loop early to continue the resize operation.

cause: EventCause

What caused the change, end-user/OS modifying the window or the app.

Implementations

impl WindowChanged

pub fn moved( window: WindowId, global_position: PxPoint, position: DipPoint, cause: EventCause, ) -> Self

Create an event that represents window move.

pub fn monitor_changed( window: WindowId, monitor: MonitorId, cause: EventCause, ) -> Self

Create an event that represents window parent monitor change.

pub fn resized( window: WindowId, size: DipSize, cause: EventCause, frame_wait_id: Option<FrameWaitId>, ) -> Self

Create an event that represents window resized.

pub fn state_changed( window: WindowId, state: WindowStateAll, cause: EventCause, ) -> Self

Create an event that represents WindowStateAll change.

Trait Implementations

impl Clone for WindowChanged

fn clone(&self) -> WindowChanged

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WindowChanged

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WindowChanged

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for WindowChanged

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.