1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License in the LICENSE-APACHE file or at:
// https://www.apache.org/licenses/LICENSE-2.0
//! Layout solver
use super::{Align, AxisInfo, Margins, SizeRules};
use crate::cast::Conv;
use crate::event::ConfigCx;
use crate::geom::{Rect, Size};
use crate::theme::SizeCx;
use crate::util::WidgetHierarchy;
use crate::{Layout, Node};
/// A [`SizeRules`] solver for layouts
///
/// Typically, a solver is invoked twice, once for each axis, before the
/// corresponding [`RulesSetter`] is invoked. This is managed by [`SolveCache`].
///
/// Implementations require access to storage able to persist between multiple
/// solver runs and a subsequent setter run. This storage is of type
/// [`RulesSolver::Storage`] and is passed via reference to the constructor.
pub trait RulesSolver {
/// Type of storage
type Storage: Clone;
/// Type required by [`RulesSolver::for_child`] (see implementation documentation)
type ChildInfo;
/// Called once for each child. For most layouts the order is important.
fn for_child<CR: FnOnce(AxisInfo) -> SizeRules>(
&mut self,
storage: &mut Self::Storage,
child_info: Self::ChildInfo,
child_rules: CR,
);
/// Called at the end to output [`SizeRules`].
///
/// Note that this does not include margins!
fn finish(self, storage: &mut Self::Storage) -> SizeRules;
}
/// Resolves a [`RulesSolver`] solution for each child
pub trait RulesSetter {
/// Type of storage
type Storage: Clone;
/// Type required by [`RulesSolver::for_child`] (see implementation documentation)
type ChildInfo;
/// Called once for each child. The order is unimportant.
fn child_rect(&mut self, storage: &mut Self::Storage, child_info: Self::ChildInfo) -> Rect;
/// Calculates the maximal rect of a given child
///
/// This assumes that all other entries have minimum size.
fn maximal_rect_of(&mut self, storage: &mut Self::Storage, index: Self::ChildInfo) -> Rect;
}
/// Solve size rules for a widget
///
/// Automatic layout solving requires that a widget's `size_rules` method is
/// called for each axis before `set_rect`. This method simply calls
/// `size_rules` on each axis.
///
/// If `size_rules` is not called, internal layout may be poor (depending on the
/// widget). If widget content changes, it is recommended to call
/// `solve_size_rules` and `set_rect` again.
///
/// Parameters `x_size` and `y_size` should be passed where this dimension is
/// fixed and are used e.g. for text wrapping.
pub fn solve_size_rules<W: Layout + ?Sized>(
widget: &mut W,
sizer: SizeCx,
x_size: Option<i32>,
y_size: Option<i32>,
h_align: Option<Align>,
v_align: Option<Align>,
) {
widget.size_rules(sizer.re(), AxisInfo::new(false, y_size, h_align));
widget.size_rules(sizer.re(), AxisInfo::new(true, x_size, v_align));
}
/// Size solver
///
/// This struct is used to solve widget layout, read size constraints and
/// cache the results until the next solver run.
///
/// [`SolveCache::find_constraints`] constructs an instance of this struct,
/// solving for size constraints.
///
/// [`SolveCache::apply_rect`] accepts a [`Rect`], updates constraints as
/// necessary and sets widget positions within this `rect`.
pub struct SolveCache {
// Technically we don't need to store min and ideal here, but it simplifies
// the API for very little real cost.
min: Size,
ideal: Size,
margins: Margins,
refresh_rules: bool,
last_width: i32,
}
impl SolveCache {
/// Get the minimum size
///
/// If `inner_margin` is true, margins are included in the result.
pub fn min(&self, inner_margin: bool) -> Size {
if inner_margin {
self.margins.pad(self.min)
} else {
self.min
}
}
/// Get the ideal size
///
/// If `inner_margin` is true, margins are included in the result.
pub fn ideal(&self, inner_margin: bool) -> Size {
if inner_margin {
self.margins.pad(self.ideal)
} else {
self.ideal
}
}
/// Get the margins
pub fn margins(&self) -> Margins {
self.margins
}
/// Calculate required size of widget
///
/// Assumes no explicit alignment.
pub fn find_constraints(mut widget: Node<'_>, sizer: SizeCx) -> Self {
let start = std::time::Instant::now();
let w = widget.size_rules(sizer.re(), AxisInfo::new(false, None, None));
let h = widget.size_rules(sizer.re(), AxisInfo::new(true, Some(w.ideal_size()), None));
let min = Size(w.min_size(), h.min_size());
let ideal = Size(w.ideal_size(), h.ideal_size());
let margins = Margins::hv(w.margins(), h.margins());
log::trace!(
target: "kas_perf::layout", "find_constraints: {}μs",
start.elapsed().as_micros(),
);
log::debug!("find_constraints: min={min:?}, ideal={ideal:?}, margins={margins:?}");
let refresh_rules = false;
let last_width = ideal.0;
SolveCache {
min,
ideal,
margins,
refresh_rules,
last_width,
}
}
/// Force updating of size rules
///
/// This should be called whenever widget size rules have been changed. It
/// forces [`SolveCache::apply_rect`] to recompute these rules when next
/// called.
pub fn invalidate_rule_cache(&mut self) {
self.refresh_rules = true;
}
/// Apply layout solution to a widget
///
/// The widget's layout is solved for the given `rect` and assigned.
/// If `inner_margin` is true, margins are internal to this `rect`; if not,
/// the caller is responsible for handling margins.
///
/// If [`SolveCache::invalidate_rule_cache`] was called since rules were
/// last calculated then this method will recalculate all rules; otherwise
/// it will only do so if necessary (when dimensions do not match those
/// last used).
pub fn apply_rect(
&mut self,
mut widget: Node<'_>,
cx: &mut ConfigCx,
mut rect: Rect,
inner_margin: bool,
) {
let start = std::time::Instant::now();
let mut width = rect.size.0;
if inner_margin {
width -= self.margins.sum_horiz();
}
// We call size_rules not because we want the result, but to allow
// internal layout solving.
if self.refresh_rules || width != self.last_width {
if self.refresh_rules {
let w = widget.size_rules(cx.size_cx(), AxisInfo::new(false, None, None));
self.min.0 = w.min_size();
self.ideal.0 = w.ideal_size();
self.margins.horiz = w.margins();
width = rect.size.0 - self.margins.sum_horiz();
}
let h = widget.size_rules(cx.size_cx(), AxisInfo::new(true, Some(width), None));
self.min.1 = h.min_size();
self.ideal.1 = h.ideal_size();
self.margins.vert = h.margins();
self.last_width = width;
}
if inner_margin {
rect.pos += Size::conv((self.margins.horiz.0, self.margins.vert.0));
rect.size.0 = width;
rect.size.1 -= self.margins.sum_vert();
}
widget.set_rect(cx, rect);
log::trace!(target: "kas_perf::layout", "apply_rect: {}μs", start.elapsed().as_micros());
self.refresh_rules = false;
}
/// Print widget heirarchy in the trace log
///
/// This is sometimes called after [`Self::apply_rect`].
pub fn print_widget_heirarchy(&mut self, widget: &dyn Layout) {
let rect = widget.rect();
let hier = WidgetHierarchy::new(widget);
log::trace!(
target: "kas_core::layout::hierarchy",
"apply_rect: rect={rect:?}:{hier}",
);
}
}