in crates/fig_desktop/src/webview/window.rs [118:309]
fn update_window_geometry(
&self,
position: Option<WindowPosition>,
size: Option<LogicalSize<f64>>,
anchor: Option<LogicalSize<f64>>,
platform_state: &PlatformState,
dry_run: bool,
) -> (bool, bool) {
// Lock our atomic state
let mut state = self.window_geometry_state.lock();
// Acquire our position, size, and anchor, and update them if dirty
let position = match position {
Some(position) if !dry_run => {
state.position = position;
position
},
Some(position) => position,
None => state.position,
};
let size = match size {
Some(size) if !dry_run => {
state.size = size;
size
},
_ => state.size,
};
let anchor = match anchor {
Some(anchor) if !dry_run => {
state.anchor = anchor;
anchor
},
_ => state.anchor,
};
let window = &self.window;
let (position, is_above, is_clipped) = match position {
WindowPosition::Absolute(position) => (position, false, false),
WindowPosition::Centered => {
let scale_factor = window.scale_factor();
let Some(monitor) = window.current_monitor() else {
return (false, false);
};
let monitor_position: LogicalPosition<f64> = monitor.position().to_logical(scale_factor);
let monitor_size: LogicalSize<f64> = monitor.size().to_logical(scale_factor);
(
Position::Logical(LogicalPosition::new(
monitor_position.x + monitor_size.width * 0.5 - size.width * 0.5,
monitor_position.y + monitor_size.height * 0.5 - size.height * 0.5,
)),
false,
false,
)
},
WindowPosition::RelativeToCaret {
caret_position,
caret_size,
origin,
} => {
let max_height = fig_settings::settings::get_int_or("autocomplete.height", 140) as f64;
let primary_monitor = window.primary_monitor();
let primary_scale_factor = primary_monitor.as_ref().map(|monitor| monitor.scale_factor());
let primary_monitor_size: Option<LogicalSize<f64>> = primary_monitor
.as_ref()
.and_then(|monitor| Some(monitor.size().to_logical(primary_scale_factor?)));
let primary_monitor_position: Option<LogicalPosition<f64>> = primary_monitor
.as_ref()
.and_then(|monitor| Some(monitor.position().to_logical(primary_scale_factor?)));
let (
caret_position,
caret_size,
overflows_monitor_above,
overflows_monitor_below,
scale_factor,
monitor_frame,
) = window
.available_monitors()
.find_map(|monitor| {
let monitor_scale_factor = monitor.scale_factor();
let monitor_frame = Rect {
position: monitor.position().into(),
size: monitor.size().into(),
};
let mut logical_caret_position: LogicalPosition<f64> =
caret_position.to_logical(primary_scale_factor.unwrap_or(monitor_scale_factor));
let logical_caret_size: LogicalSize<f64> =
caret_size.to_logical(primary_scale_factor.unwrap_or(monitor_scale_factor));
match origin {
Origin::BottomLeft => {
logical_caret_position.y =
primary_monitor_position.map(|position| position.y).unwrap_or_default()
+ primary_monitor_size.map(|size| size.height).unwrap_or_default()
- logical_caret_position.y
- logical_caret_size.height;
},
Origin::TopLeft => {
// This is the default
},
}
monitor_frame
.contains(logical_caret_position.into(), monitor_scale_factor)
.then(|| {
let monitor_position: LogicalPosition<f64> =
monitor.position().to_logical(monitor_scale_factor);
let monitor_size: LogicalSize<f64> = monitor.size().to_logical(monitor_scale_factor);
(
logical_caret_position,
logical_caret_size,
monitor_position.y >= logical_caret_position.y - max_height,
monitor_position.y + monitor_size.height
< logical_caret_position.y + logical_caret_size.height + max_height,
monitor_scale_factor,
Some((monitor_position, monitor_size)),
)
})
})
.unwrap_or_else(|| {
(
caret_position.to_logical(1.0),
caret_size.to_logical(1.0),
false,
false,
1.0,
None,
)
});
let overflows_window_below = platform_state.get_active_window().is_some_and(|window| {
window.rect.bottom(scale_factor) < max_height + caret_position.y + caret_size.height
});
let above = !overflows_monitor_above & (overflows_monitor_below | overflows_window_below);
let mut x: f64 = caret_position.x + anchor.width;
let mut y: f64 = match above {
true => caret_position.y - size.height - anchor.height,
false => caret_position.y + caret_size.height + anchor.height,
};
#[allow(clippy::all)]
let clipped = if let Some((monitor_position, monitor_size)) = &monitor_frame {
let clipped = caret_position.x + size.width > monitor_position.x + monitor_size.width;
x = x
.min(monitor_position.x + monitor_size.width - size.width)
.max(monitor_position.x);
y = y
.min(monitor_position.y + monitor_size.height - size.height)
.max(monitor_position.y);
clipped
} else {
false
};
(Position::Logical(LogicalPosition::new(x, y)), above, clipped)
},
};
if !dry_run {
match platform_state.position_window(&self.window, &self.window_id, position) {
Ok(_) => {
tracing::trace!(window_id =% self.window_id, ?position, ?is_above, ?is_clipped, "updated window geometry: first set");
},
Err(err) => tracing::error!(%err, window_id =% self.window_id, "failed to position window"),
}
// Apply the diff to atomic state
self.window.set_inner_size(size);
match platform_state.position_window(&self.window, &self.window_id, position) {
Ok(_) => {
tracing::trace!(window_id =% self.window_id,"updated window geometry: second set");
},
Err(err) => tracing::error!(%err, window_id =% self.window_id, "failed to position window"),
}
}
(is_above, is_clipped)
}