SYMBOL INDEX (5744 symbols across 343 files)

FILE: beacon/src/client.rs
  type Client (line 19) | pub struct Client {
    method log (line 55) | pub fn log(&self, event: Event) {
    method is_connected (line 62) | pub fn is_connected(&self) -> bool {
    method quit (line 66) | pub fn quit(&self) {
    method subscribe (line 72) | pub fn subscribe(&self) -> mpsc::Receiver<Command> {
  type Message (line 26) | pub enum Message {
  type Event (line 44) | pub enum Event {
  type Metadata (line 81) | pub struct Metadata {
  function connect (line 88) | pub fn connect(metadata: Metadata) -> Client {
  type Action (line 105) | enum Action {
  type Command (line 111) | pub enum Command {
  function run (line 117) | async fn run(
  function server_address_from_env (line 221) | pub fn server_address_from_env() -> String {
  function _connect (line 227) | async fn _connect() -> Result<net::TcpStream, io::Error> {
  function send (line 237) | async fn send(stream: &mut net::tcp::OwnedWriteHalf, message: Message) -...
  function receive (line 248) | async fn receive(

FILE: beacon/src/error.rs
  type Error (line 4) | pub enum Error {

FILE: beacon/src/lib.rs
  type Connection (line 25) | pub struct Connection {
    method rewind_to (line 30) | pub fn rewind_to<'a>(&self, message: usize) -> impl Future<Output = ()...
    method go_live (line 38) | pub fn go_live<'a>(&self) -> impl Future<Output = ()> + 'a {
  type Event (line 48) | pub enum Event {
    method at (line 78) | pub fn at(&self) -> SystemTime {
  function is_running (line 90) | pub fn is_running() -> bool {
  function run (line 94) | pub fn run() -> impl Stream<Item = Event> {
  function receive (line 282) | async fn receive(
  function send (line 297) | async fn send(
  function delay (line 311) | async fn delay() {

FILE: beacon/src/span.rs
  type Span (line 6) | pub enum Span {
  type Stage (line 38) | pub enum Stage {
    method fmt (line 52) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Stage (line 74) | pub struct Stage {
    method fmt (line 52) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Primitive (line 83) | pub enum Primitive {

FILE: beacon/src/stream.rs
  function channel (line 5) | pub fn channel<T, F>(f: impl Fn(mpsc::Sender<T>) -> F) -> impl Stream<It...

FILE: benches/wgpu.rs
  function wgpu_benchmark (line 15) | pub fn wgpu_benchmark(c: &mut Criterion) {
  function benchmark (line 72) | fn benchmark<'a>(
  function scene (line 151) | fn scene<'a, Message: 'a>(n: usize) -> Element<'a, Message, Theme, Rende...
  function layered_text (line 202) | fn layered_text<'a, Message: 'a>(n: usize) -> Element<'a, Message, Theme...
  function dynamic_text (line 209) | fn dynamic_text<'a, Message: 'a>(n: usize, i: usize) -> Element<'a, Mess...
  function advanced_shaping (line 225) | fn advanced_shaping<'a, Message: 'a>(n: usize, i: usize) -> Element<'a, ...

FILE: core/src/alignment.rs
  type Alignment (line 5) | pub enum Alignment {
    method from (line 17) | fn from(horizontal: Horizontal) -> Self {
    method from (line 27) | fn from(vertical: Vertical) -> Self {
  type Horizontal (line 38) | pub enum Horizontal {
    method from (line 50) | fn from(alignment: Alignment) -> Self {
  type Vertical (line 61) | pub enum Vertical {
    method from (line 73) | fn from(alignment: Alignment) -> Self {

FILE: core/src/angle.rs
  type Degrees (line 9) | pub struct Degrees(pub f32);
    constant RANGE (line 13) | pub const RANGE: RangeInclusive<Self> = Self(0.0)..=Self(360.0);
    method eq (line 17) | fn eq(&self, other: &f32) -> bool {
    method partial_cmp (line 23) | fn partial_cmp(&self, other: &f32) -> Option<std::cmp::Ordering> {
    method from (line 29) | fn from(degrees: f32) -> Self {
    method from (line 35) | fn from(degrees: u8) -> Self {
    type Output (line 53) | type Output = Degrees;
    method mul (line 55) | fn mul(self, rhs: f32) -> Self::Output {
    method from_i64 (line 61) | fn from_i64(n: i64) -> Option<Self> {
    method from_u64 (line 65) | fn from_u64(n: u64) -> Option<Self> {
    method from_f64 (line 69) | fn from_f64(n: f64) -> Option<Self> {
  function from (line 41) | fn from(degrees: Degrees) -> Self {
  function from (line 47) | fn from(degrees: Degrees) -> Self {
  type Radians (line 76) | pub struct Radians(pub f32);
    constant RANGE (line 80) | pub const RANGE: RangeInclusive<Self> = Self(0.0)..=Self(2.0 * PI);
    constant PI (line 83) | pub const PI: Self = Self(PI);
    method to_distance (line 86) | pub fn to_distance(&self, bounds: &Rectangle) -> (Point, Point) {
    method from (line 103) | fn from(degrees: Degrees) -> Self {
    method from (line 109) | fn from(radians: f32) -> Self {
    method from (line 115) | fn from(radians: u8) -> Self {
    method from_i64 (line 133) | fn from_i64(n: i64) -> Option<Self> {
    method from_u64 (line 137) | fn from_u64(n: u64) -> Option<Self> {
    method from_f64 (line 141) | fn from_f64(n: f64) -> Option<Self> {
    type Output (line 169) | type Output = Self;
    method add (line 171) | fn add(self, rhs: Degrees) -> Self::Output {
    type Output (line 191) | type Output = Self;
    method mul (line 193) | fn mul(self, rhs: f32) -> Self::Output {
    type Output (line 207) | type Output = Self;
    method div (line 209) | fn div(self, rhs: f32) -> Self::Output {
    method eq (line 231) | fn eq(&self, other: &f32) -> bool {
    method partial_cmp (line 237) | fn partial_cmp(&self, other: &f32) -> Option<std::cmp::Ordering> {
  function from (line 121) | fn from(radians: Radians) -> Self {
  function from (line 127) | fn from(radians: Radians) -> Self {
  type Output (line 147) | type Output = Self;
  method sub (line 149) | fn sub(self, rhs: Self) -> Self::Output {
  method sub_assign (line 155) | fn sub_assign(&mut self, rhs: Self) {
  type Output (line 161) | type Output = Self;
  method add (line 163) | fn add(self, rhs: Self) -> Self::Output {
  method add_assign (line 177) | fn add_assign(&mut self, rhs: Radians) {
  type Output (line 183) | type Output = Self;
  method mul (line 185) | fn mul(self, rhs: Radians) -> Self::Output {
  type Output (line 199) | type Output = Radians;
  function mul (line 201) | fn mul(self, rhs: Radians) -> Self::Output {
  type Output (line 215) | type Output = Self;
  method div (line 217) | fn div(self, rhs: Self) -> Self::Output {
  type Output (line 223) | type Output = Self;
  method rem (line 225) | fn rem(self, rhs: Self) -> Self::Output {
  method fmt (line 243) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: core/src/animation.rs
  type Animation (line 11) | pub struct Animation<T>
  function new (line 24) | pub fn new(state: T) -> Self {
  function easing (line 35) | pub fn easing(mut self, easing: Easing) -> Self {
  function very_quick (line 41) | pub fn very_quick(self) -> Self {
  function quick (line 46) | pub fn quick(self) -> Self {
  function slow (line 51) | pub fn slow(self) -> Self {
  function very_slow (line 56) | pub fn very_slow(self) -> Self {
  function duration (line 61) | pub fn duration(mut self, duration: Duration) -> Self {
  function delay (line 68) | pub fn delay(mut self, duration: Duration) -> Self {
  function repeat (line 76) | pub fn repeat(mut self, repetitions: u32) -> Self {
  function repeat_forever (line 82) | pub fn repeat_forever(mut self) -> Self {
  function auto_reverse (line 88) | pub fn auto_reverse(mut self) -> Self {
  function go (line 95) | pub fn go(mut self, new_state: T, at: Instant) -> Self {
  function go_mut (line 102) | pub fn go_mut(&mut self, new_state: T, at: Instant) {
  function is_animating (line 109) | pub fn is_animating(&self, at: Instant) -> bool {
  function interpolate_with (line 119) | pub fn interpolate_with<I>(&self, f: impl Fn(T) -> I, at: Instant) -> I
  function value (line 127) | pub fn value(&self) -> T {
  function interpolate (line 135) | pub fn interpolate<I>(&self, start: I, end: I, at: Instant) -> I
  function remaining (line 143) | pub fn remaining(&self, at: Instant) -> Duration {

FILE: core/src/background.rs
  type Background (line 6) | pub enum Background {
    method scale_alpha (line 17) | pub fn scale_alpha(self, factor: f32) -> Self {
    method from (line 26) | fn from(color: Color) -> Self {
    method from (line 32) | fn from(gradient: Gradient) -> Self {
    method from (line 38) | fn from(gradient: gradient::Linear) -> Self {

FILE: core/src/border.rs
  type Border (line 6) | pub struct Border {
    method color (line 54) | pub fn color(self, color: impl Into<Color>) -> Self {
    method rounded (line 62) | pub fn rounded(self, radius: impl Into<Radius>) -> Self {
    method width (line 70) | pub fn width(self, width: impl Into<Pixels>) -> Self {
  function rounded (line 24) | pub fn rounded(radius: impl Into<Radius>) -> Border {
  function color (line 36) | pub fn color(color: impl Into<Color>) -> Border {
  function width (line 48) | pub fn width(width: impl Into<Pixels>) -> Border {
  type Radius (line 81) | pub struct Radius {
    method new (line 139) | pub fn new(value: impl Into<Pixels>) -> Self {
    method top_left (line 151) | pub fn top_left(self, value: impl Into<Pixels>) -> Self {
    method top_right (line 159) | pub fn top_right(self, value: impl Into<Pixels>) -> Self {
    method bottom_right (line 167) | pub fn bottom_right(self, value: impl Into<Pixels>) -> Self {
    method bottom_left (line 175) | pub fn bottom_left(self, value: impl Into<Pixels>) -> Self {
    method top (line 183) | pub fn top(self, value: impl Into<Pixels>) -> Self {
    method bottom (line 194) | pub fn bottom(self, value: impl Into<Pixels>) -> Self {
    method left (line 205) | pub fn left(self, value: impl Into<Pixels>) -> Self {
    method right (line 216) | pub fn right(self, value: impl Into<Pixels>) -> Self {
    method from (line 228) | fn from(radius: f32) -> Self {
    method from (line 239) | fn from(w: u8) -> Self {
    method from (line 245) | fn from(w: u32) -> Self {
    method from (line 251) | fn from(w: i32) -> Self {
    type Output (line 268) | type Output = Self;
    method mul (line 270) | fn mul(self, scale: f32) -> Self::Output {
  function radius (line 93) | pub fn radius(value: impl Into<Pixels>) -> Radius {
  function top_left (line 98) | pub fn top_left(value: impl Into<Pixels>) -> Radius {
  function top_right (line 103) | pub fn top_right(value: impl Into<Pixels>) -> Radius {
  function bottom_right (line 108) | pub fn bottom_right(value: impl Into<Pixels>) -> Radius {
  function bottom_left (line 113) | pub fn bottom_left(value: impl Into<Pixels>) -> Radius {
  function top (line 118) | pub fn top(value: impl Into<Pixels>) -> Radius {
  function bottom (line 123) | pub fn bottom(value: impl Into<Pixels>) -> Radius {
  function left (line 128) | pub fn left(value: impl Into<Pixels>) -> Radius {
  function right (line 133) | pub fn right(value: impl Into<Pixels>) -> Radius {
  function from (line 257) | fn from(radi: Radius) -> Self {

FILE: core/src/clipboard.rs
  type Clipboard (line 7) | pub struct Clipboard {
    method new (line 17) | pub fn new() -> Self {
    method merge (line 25) | pub fn merge(&mut self, other: &mut Self) {
  method default (line 32) | fn default() -> Self {
  type Event (line 39) | pub enum Event {
  type Content (line 51) | pub enum Content {
    method from (line 60) | fn from(text: String) -> Self {
    method from (line 67) | fn from(image: Image) -> Self {
    method from (line 73) | fn from(files: Vec<PathBuf>) -> Self {
  type Kind (line 82) | pub enum Kind {
  type Image (line 93) | pub struct Image {
  type Error (line 103) | pub enum Error {

FILE: core/src/color.rs
  type Color (line 19) | pub struct Color {
    constant BLACK (line 32) | pub const BLACK: Color = Color {
    constant WHITE (line 40) | pub const WHITE: Color = Color {
    constant TRANSPARENT (line 48) | pub const TRANSPARENT: Color = Color {
    method new (line 59) | const fn new(r: f32, g: f32, b: f32, a: f32) -> Color {
    method from_rgb (line 77) | pub const fn from_rgb(r: f32, g: f32, b: f32) -> Self {
    method from_rgba (line 82) | pub const fn from_rgba(r: f32, g: f32, b: f32, a: f32) -> Self {
    method from_rgb8 (line 87) | pub const fn from_rgb8(r: u8, g: u8, b: u8) -> Self {
    method from_rgba8 (line 92) | pub const fn from_rgba8(r: u8, g: u8, b: u8, a: f32) -> Self {
    method from_packed_rgb8 (line 97) | pub const fn from_packed_rgb8(rgb: u32) -> Self {
    method from_packed_rgba8 (line 103) | pub const fn from_packed_rgba8(rgb: u32, a: f32) -> Self {
    method from_linear_rgba (line 112) | pub fn from_linear_rgba(r: f32, g: f32, b: f32, a: f32) -> Self {
    method invert (line 132) | pub const fn invert(&mut self) {
    method inverse (line 139) | pub const fn inverse(self) -> Self {
    method scale_alpha (line 144) | pub const fn scale_alpha(self, factor: f32) -> Self {
    method mix (line 152) | pub fn mix(self, b: Color, factor: f32) -> Color {
    method relative_luminance (line 170) | pub fn relative_luminance(self) -> f32 {
    method relative_contrast (line 179) | pub fn relative_contrast(self, b: Self) -> f32 {
    method is_readable_on (line 189) | pub fn is_readable_on(self, background: Self) -> bool {
    method into_rgba8 (line 195) | pub const fn into_rgba8(self) -> [u8; 4] {
    method into_linear (line 206) | pub fn into_linear(self) -> [f32; 4] {
    method from (line 227) | fn from([r, g, b]: [f32; 3]) -> Self {
    method from (line 233) | fn from([r, g, b, a]: [f32; 4]) -> Self {
    type Err (line 252) | type Err = ParseError;
    method from_str (line 254) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method fmt (line 295) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ParseError (line 242) | pub enum ParseError {
  method interpolated (line 308) | fn interpolated(&self, other: Self, ratio: f32) -> Self {
  function parse (line 355) | fn parse() {
  constant SHORTHAND (line 374) | const SHORTHAND: Color = color!(0x123);
  function shorthand_notation (line 377) | fn shorthand_notation() {

FILE: core/src/content_fit.rs
  type ContentFit (line 17) | pub enum ContentFit {
    method fit (line 72) | pub fn fit(&self, content: Size, bounds: Size) -> Size {
    method fmt (line 125) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/src/element.rs
  type Element (line 20) | pub struct Element<'a, Message, Theme, Renderer> {
  function new (line 26) | pub fn new(widget: impl Widget<Message, Theme, Renderer> + 'a) -> Self
  function as_widget (line 36) | pub fn as_widget(&self) -> &dyn Widget<Message, Theme, Renderer> {
  function as_widget_mut (line 41) | pub fn as_widget_mut(&mut self) -> &mut dyn Widget<Message, Theme, Rende...
  function map (line 184) | pub fn map<B>(self, f: impl Fn(Message) -> B + 'a) -> Element<'a, B, The...
  function explain (line 200) | pub fn explain<C: Into<Color>>(self, color: C) -> Element<'a, Message, T...
  function borrow (line 215) | fn borrow(&self) -> &(dyn Widget<Message, Theme, Renderer> + 'a) {
  function borrow (line 223) | fn borrow(&self) -> &(dyn Widget<Message, Theme, Renderer> + 'a) {
  type Map (line 228) | struct Map<'a, A, B, Theme, Renderer> {
  function new (line 234) | pub fn new<F>(
  function tag (line 254) | fn tag(&self) -> tree::Tag {
  function state (line 258) | fn state(&self) -> tree::State {
  function children (line 262) | fn children(&self) -> Vec<Tree> {
  function diff (line 266) | fn diff(&self, tree: &mut Tree) {
  function size (line 270) | fn size(&self) -> Size<Length> {
  function size_hint (line 274) | fn size_hint(&self) -> Size<Length> {
  function layout (line 278) | fn layout(
  function operate (line 287) | fn operate(
  function update (line 297) | fn update(
  function draw (line 323) | fn draw(
  function mouse_interaction (line 337) | fn mouse_interaction(
  function overlay (line 349) | fn overlay<'b>(
  type Explain (line 365) | struct Explain<'a, Message, Theme, Renderer: crate::Renderer> {
  function new (line 374) | fn new(element: Element<'a, Message, Theme, Renderer>, color: Color) -> ...
  function size (line 384) | fn size(&self) -> Size<Length> {
  function size_hint (line 388) | fn size_hint(&self) -> Size<Length> {
  function tag (line 392) | fn tag(&self) -> tree::Tag {
  function state (line 396) | fn state(&self) -> tree::State {
  function children (line 400) | fn children(&self) -> Vec<Tree> {
  function diff (line 404) | fn diff(&self, tree: &mut Tree) {
  function layout (line 408) | fn layout(
  function operate (line 417) | fn operate(
  function update (line 429) | fn update(
  function draw (line 444) | fn draw(
  function mouse_interaction (line 486) | fn mouse_interaction(
  function overlay (line 499) | fn overlay<'b>(
  function from (line 518) | fn from(element: Option<T>) -> Self {

FILE: core/src/event.rs
  type Event (line 16) | pub enum Event {
  type Status (line 38) | pub enum Status {
    method merge (line 59) | pub fn merge(self, b: Self) -> Self {

FILE: core/src/font.rs
  type Font (line 6) | pub struct Font {
    constant DEFAULT (line 19) | pub const DEFAULT: Font = Font {
    constant MONOSPACE (line 27) | pub const MONOSPACE: Font = Font {
    method new (line 33) | pub const fn new(name: &'static str) -> Self {
    method with_family (line 41) | pub fn with_family(family: impl Into<Family>) -> Self {
    method weight (line 49) | pub const fn weight(self, weight: Weight) -> Self {
    method stretch (line 54) | pub const fn stretch(self, stretch: Stretch) -> Self {
    method style (line 59) | pub const fn style(self, style: Style) -> Self {
    method from (line 65) | fn from(name: &'static str) -> Self {
    method from (line 71) | fn from(family: Family) -> Self {
  type Family (line 78) | pub enum Family {
    constant VARIANTS (line 107) | pub const VARIANTS: &[Self] = &[
    method name (line 118) | pub fn name(name: &str) -> Self {
    method from (line 138) | fn from(name: &str) -> Self {
    method fmt (line 144) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Weight (line 159) | pub enum Weight {
  type Stretch (line 175) | pub enum Stretch {
  type Style (line 191) | pub enum Style {
  type Error (line 200) | pub enum Error {}

FILE: core/src/gradient.rs
  type Gradient (line 9) | pub enum Gradient {
    method scale_alpha (line 16) | pub fn scale_alpha(self, factor: f32) -> Self {
    method from (line 24) | fn from(gradient: Linear) -> Self {
  type ColorStop (line 33) | pub struct ColorStop {
  type Linear (line 45) | pub struct Linear {
    method new (line 54) | pub fn new(angle: impl Into<Radians>) -> Self {
    method add_stop (line 66) | pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
    method add_stops (line 86) | pub fn add_stops(mut self, stops: impl IntoIterator<Item = ColorStop>)...
    method scale_alpha (line 96) | pub fn scale_alpha(mut self, factor: f32) -> Self {

FILE: core/src/image.rs
  type Image (line 14) | pub struct Image<H = Handle> {
    method from (line 67) | fn from(handle: &Handle) -> Self {
  function new (line 37) | pub fn new(handle: impl Into<Handle>) -> Self {
  function filter_method (line 48) | pub fn filter_method(mut self, filter_method: FilterMethod) -> Self {
  function rotation (line 54) | pub fn rotation(mut self, rotation: impl Into<Radians>) -> Self {
  function opacity (line 60) | pub fn opacity(mut self, opacity: impl Into<f32>) -> Self {
  type Handle (line 74) | pub enum Handle {
    method from_path (line 111) | pub fn from_path<T: Into<PathBuf>>(path: T) -> Handle {
    method from_bytes (line 123) | pub fn from_bytes(bytes: impl Into<Bytes>) -> Handle {
    method from_rgba (line 134) | pub fn from_rgba(width: u32, height: u32, pixels: impl Into<Bytes>) ->...
    method id (line 144) | pub fn id(&self) -> Id {
    method from (line 155) | fn from(path: T) -> Handle {
    method from (line 161) | fn from(value: &Handle) -> Self {
    method fmt (line 167) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Id (line 182) | pub struct Id(_Id);
    method unique (line 191) | fn unique() -> Self {
    method path (line 199) | fn path(path: impl AsRef<Path>) -> Self {
  type _Id (line 185) | enum _Id {
  type FilterMethod (line 213) | pub enum FilterMethod {
  type Allocation (line 237) | pub struct Allocation(Arc<Memory>);
    method downgrade (line 248) | pub fn downgrade(&self) -> Weak<Memory> {
    method upgrade (line 253) | pub fn upgrade(weak: &Weak<Memory>) -> Option<Allocation> {
    method handle (line 258) | pub fn handle(&self) -> &Handle {
    method size (line 263) | pub fn size(&self) -> Size<u32> {
  type Memory (line 241) | pub struct Memory {
  function allocate (line 275) | pub unsafe fn allocate(handle: &Handle, size: Size<u32>) -> Allocation {
  type Renderer (line 285) | pub trait Renderer: crate::Renderer {
    method load_image (line 295) | fn load_image(&self, handle: &Self::Handle) -> Result<Allocation, Error>;
    method measure_image (line 303) | fn measure_image(&self, handle: &Self::Handle) -> Option<Size<u32>>;
    method draw_image (line 312) | fn draw_image(&mut self, image: Image<Self::Handle>, bounds: Rectangle...
  type Error (line 317) | pub enum Error {

FILE: core/src/input_method.rs
  type InputMethod (line 8) | pub enum InputMethod<T = String> {
    method merge (line 112) | pub fn merge<T: AsRef<str>>(&mut self, other: &InputMethod<T>) {
    method is_enabled (line 121) | pub fn is_enabled(&self) -> bool {
  type Preedit (line 30) | pub struct Preedit<T = String> {
    method as_ref (line 63) | pub fn as_ref(&self) -> Preedit<&str> {
  function new (line 41) | pub fn new() -> Self
  function to_owned (line 49) | pub fn to_owned(&self) -> Preedit
  type Purpose (line 74) | pub enum Purpose {
  function to_owned (line 128) | pub fn to_owned(&self) -> InputMethod
  type Event (line 157) | pub enum Event {

FILE: core/src/keyboard/event.rs
  type Event (line 12) | pub enum Event {

FILE: core/src/keyboard/key.rs
  type Key (line 10) | pub enum Key<C = SmolStr> {
    method as_ref (line 26) | pub fn as_ref(&self) -> Key<&str> {
    method to_latin (line 60) | pub fn to_latin(&self, physical_key: Physical) -> Option<char> {
    method from (line 121) | fn from(named: Named) -> Self {
  type Named (line 133) | pub enum Named {
  type Code (line 849) | pub enum Code {
    method eq (line 1348) | fn eq(&self, rhs: &Physical) -> bool {
  type NativeCode (line 1307) | pub enum NativeCode {
    method eq (line 1365) | fn eq(&self, rhs: &Physical) -> bool {
  type Physical (line 1325) | pub enum Physical {
    method eq (line 1338) | fn eq(&self, rhs: &Code) -> bool {
    method eq (line 1355) | fn eq(&self, rhs: &NativeCode) -> bool {

FILE: core/src/keyboard/location.rs
  type Location (line 3) | pub enum Location {

FILE: core/src/keyboard/modifiers.rs
  constant COMMAND (line 39) | pub const COMMAND: Self = if cfg!(target_os = "macos") {
  method shift (line 48) | pub fn shift(self) -> bool {
  method control (line 55) | pub fn control(self) -> bool {
  method alt (line 62) | pub fn alt(self) -> bool {
  method logo (line 69) | pub fn logo(self) -> bool {
  method command (line 80) | pub fn command(self) -> bool {
  method jump (line 94) | pub fn jump(self) -> bool {
  method macos_command (line 106) | pub fn macos_command(self) -> bool {

FILE: core/src/layout.rs
  type Layout (line 14) | pub struct Layout<'a> {
  function new (line 21) | pub fn new(node: &'a Node) -> Self {
  function with_offset (line 27) | pub fn with_offset(offset: Vector, node: &'a Node) -> Self {
  function position (line 37) | pub fn position(&self) -> Point {
  function bounds (line 45) | pub fn bounds(&self) -> Rectangle {
  function children (line 57) | pub fn children(self) -> impl DoubleEndedIterator<Item = Layout<'a>> + E...
  function child (line 70) | pub fn child(self, index: usize) -> Layout<'a> {
  function next_to_each_other (line 78) | pub fn next_to_each_other(
  function atomic (line 112) | pub fn atomic(limits: &Limits, width: impl Into<Length>, height: impl In...
  function sized (line 122) | pub fn sized(
  function contained (line 140) | pub fn contained(
  function padded (line 158) | pub fn padded(
  function positioned (line 169) | pub fn positioned(

FILE: core/src/layout/flex.rs
  type Axis (line 27) | pub enum Axis {
    method main (line 36) | fn main(&self, size: Size) -> f32 {
    method cross (line 43) | fn cross(&self, size: Size) -> f32 {
    method pack (line 50) | fn pack<T>(&self, main: T, cross: T) -> (T, T) {
  function resolve (line 62) | pub fn resolve<Message, Theme, Renderer>(

FILE: core/src/layout/limits.rs
  type Limits (line 6) | pub struct Limits {
    constant NONE (line 14) | pub const NONE: Limits = Limits {
    method new (line 21) | pub const fn new(min: Size, max: Size) -> Limits {
    method with_compression (line 27) | pub const fn with_compression(min: Size, max: Size, compress: Size<boo...
    method min (line 36) | pub fn min(&self) -> Size {
    method max (line 41) | pub fn max(&self) -> Size {
    method compression (line 46) | pub fn compression(&self) -> Size<bool> {
    method width (line 51) | pub fn width(mut self, width: impl Into<Length>) -> Limits {
    method height (line 70) | pub fn height(mut self, height: impl Into<Length>) -> Limits {
    method min_width (line 89) | pub fn min_width(mut self, min_width: f32) -> Limits {
    method max_width (line 96) | pub fn max_width(mut self, max_width: f32) -> Limits {
    method min_height (line 103) | pub fn min_height(mut self, min_height: f32) -> Limits {
    method max_height (line 110) | pub fn max_height(mut self, max_height: f32) -> Limits {
    method shrink (line 117) | pub fn shrink(&self, size: impl Into<Size>) -> Limits {
    method loose (line 138) | pub fn loose(&self) -> Limits {
    method resolve (line 149) | pub fn resolve(

FILE: core/src/layout/node.rs
  type Node (line 5) | pub struct Node {
    method new (line 12) | pub const fn new(size: Size) -> Self {
    method with_children (line 17) | pub const fn with_children(size: Size, children: Vec<Node>) -> Self {
    method container (line 30) | pub fn container(child: Self, padding: Padding) -> Self {
    method size (line 38) | pub fn size(&self) -> Size {
    method bounds (line 43) | pub fn bounds(&self) -> Rectangle {
    method children (line 48) | pub fn children(&self) -> &[Node] {
    method align (line 53) | pub fn align(mut self, align_x: Alignment, align_y: Alignment, space: ...
    method align_mut (line 59) | pub fn align_mut(&mut self, align_x: Alignment, align_y: Alignment, sp...
    method move_to (line 82) | pub fn move_to(mut self, position: impl Into<Point>) -> Self {
    method move_to_mut (line 88) | pub fn move_to_mut(&mut self, position: impl Into<Point>) {
    method translate (line 96) | pub fn translate(mut self, translation: impl Into<Vector>) -> Self {
    method translate_mut (line 102) | pub fn translate_mut(&mut self, translation: impl Into<Vector>) {

FILE: core/src/length.rs
  type Length (line 5) | pub enum Length {
    method fill_factor (line 31) | pub fn fill_factor(&self) -> u16 {
    method is_fill (line 42) | pub fn is_fill(&self) -> bool {
    method fluid (line 51) | pub fn fluid(&self) -> Self {
    method enclose (line 61) | pub fn enclose(self, other: Length) -> Self {
    method from (line 70) | fn from(amount: Pixels) -> Self {
    method from (line 76) | fn from(amount: f32) -> Self {
    method from (line 82) | fn from(units: u32) -> Self {

FILE: core/src/lib.rs
  function never (line 95) | pub fn never<T>(never: Never) -> T {
  type Function (line 103) | pub trait Function<A, B, O> {
    method with (line 142) | fn with(self, prefix: A) -> impl Fn(B) -> O;
  method with (line 151) | fn with(self, prefix: A) -> impl Fn(B) -> O {

FILE: core/src/mouse/button.rs
  type Button (line 3) | pub enum Button {

FILE: core/src/mouse/click.rs
  type Click (line 10) | pub struct Click {
    method new (line 43) | pub fn new(position: Point, button: Button, previous: Option<Click>) -...
    method kind (line 65) | pub fn kind(&self) -> Kind {
    method position (line 70) | pub fn position(&self) -> Point {
    method is_consecutive (line 74) | fn is_consecutive(&self, new_position: Point, time: Instant) -> bool {
    type Output (line 89) | type Output = Click;
    method mul (line 91) | fn mul(self, transformation: Transformation) -> Click {
  type Kind (line 19) | pub enum Kind {
    method next (line 31) | fn next(self) -> Kind {

FILE: core/src/mouse/cursor.rs
  type Cursor (line 5) | pub enum Cursor {
    method position (line 19) | pub fn position(self) -> Option<Point> {
    method position_over (line 31) | pub fn position_over(self, bounds: Rectangle) -> Option<Point> {
    method position_in (line 40) | pub fn position_in(self, bounds: Rectangle) -> Option<Point> {
    method position_from (line 47) | pub fn position_from(self, origin: Point) -> Option<Point> {
    method is_over (line 52) | pub fn is_over(self, bounds: Rectangle) -> bool {
    method is_levitating (line 57) | pub fn is_levitating(self) -> bool {
    method levitate (line 62) | pub fn levitate(self) -> Self {
    method land (line 70) | pub fn land(self) -> Self {
    type Output (line 79) | type Output = Self;
    method add (line 81) | fn add(self, translation: Vector) -> Self::Output {
    type Output (line 91) | type Output = Self;
    method sub (line 93) | fn sub(self, translation: Vector) -> Self::Output {
    type Output (line 103) | type Output = Self;
    method mul (line 105) | fn mul(self, transformation: Transformation) -> Self {

FILE: core/src/mouse/event.rs
  type Event (line 12) | pub enum Event {
  type ScrollDelta (line 40) | pub enum ScrollDelta {

FILE: core/src/mouse/interaction.rs
  type Interaction (line 4) | pub enum Interaction {

FILE: core/src/overlay.rs
  type Overlay (line 18) | pub trait Overlay<Message, Theme, Renderer>
    method layout (line 28) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node;
    method draw (line 31) | fn draw(
    method operate (line 41) | fn operate(
    method update (line 52) | fn update(
    method mouse_interaction (line 65) | fn mouse_interaction(
    method overlay (line 75) | fn overlay<'a>(
    method index (line 89) | fn index(&self) -> f32 {
  function from_children (line 98) | pub fn from_children<'a, Message, Theme, Renderer>(

FILE: core/src/overlay/element.rs
  type Element (line 10) | pub struct Element<'a, Message, Theme, Renderer> {
  function new (line 19) | pub fn new(overlay: Box<dyn Overlay<Message, Theme, Renderer> + 'a>) -> ...
  function as_overlay (line 24) | pub fn as_overlay(&self) -> &dyn Overlay<Message, Theme, Renderer> {
  function as_overlay_mut (line 29) | pub fn as_overlay_mut(&mut self) -> &mut dyn Overlay<Message, Theme, Ren...
  function map (line 34) | pub fn map<B>(self, f: &'a dyn Fn(Message) -> B) -> Element<'a, B, Theme...
  type Map (line 47) | struct Map<'a, A, B, Theme, Renderer> {
  function new (line 53) | pub fn new(
  function layout (line 65) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function operate (line 69) | fn operate(
  function update (line 78) | fn update(
  function mouse_interaction (line 95) | fn mouse_interaction(
  function draw (line 104) | fn draw(
  function overlay (line 115) | fn overlay<'a>(

FILE: core/src/overlay/group.rs
  type Group (line 10) | pub struct Group<'a, Message, Theme, Renderer> {
  function new (line 21) | pub fn new() -> Self {
  function with_children (line 26) | pub fn with_children(
  function overlay (line 42) | pub fn overlay(self) -> overlay::Element<'a, Message, Theme, Renderer> {
  method default (line 53) | fn default() -> Self {
  function layout (line 63) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function update (line 73) | fn update(
  function draw (line 88) | fn draw(
  function mouse_interaction (line 103) | fn mouse_interaction(
  function operate (line 121) | fn operate(
  function overlay (line 137) | fn overlay<'a>(
  function index (line 152) | fn index(&self) -> f32 {
  function from (line 167) | fn from(group: Group<'a, Message, Theme, Renderer>) -> Self {

FILE: core/src/overlay/nested.rs
  type Nested (line 10) | pub struct Nested<'a, Message, Theme, Renderer> {
  function new (line 19) | pub fn new(element: overlay::Element<'a, Message, Theme, Renderer>) -> S...
  function layout (line 26) | pub fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::N...
  function draw (line 54) | pub fn draw(
  function operate (line 118) | pub fn operate(
  function update (line 151) | pub fn update(
  function mouse_interaction (line 221) | pub fn mouse_interaction(

FILE: core/src/padding.rs
  type Padding (line 36) | pub struct Padding {
    constant ZERO (line 84) | pub const ZERO: Padding = Padding {
    method new (line 92) | pub const fn new(padding: f32) -> Padding {
    method top (line 104) | pub fn top(self, top: impl Into<Pixels>) -> Self {
    method bottom (line 114) | pub fn bottom(self, bottom: impl Into<Pixels>) -> Self {
    method left (line 124) | pub fn left(self, left: impl Into<Pixels>) -> Self {
    method right (line 134) | pub fn right(self, right: impl Into<Pixels>) -> Self {
    method horizontal (line 145) | pub fn horizontal(self, horizontal: impl Into<Pixels>) -> Self {
    method vertical (line 159) | pub fn vertical(self, vertical: impl Into<Pixels>) -> Self {
    method x (line 170) | pub fn x(self) -> f32 {
    method y (line 175) | pub fn y(self) -> f32 {
    method fit (line 180) | pub fn fit(self, inner: Size, outer: Size) -> Self {
    method from (line 195) | fn from(p: u16) -> Self {
    method from (line 206) | fn from(p: [u16; 2]) -> Self {
    method from (line 217) | fn from(p: f32) -> Self {
    method from (line 228) | fn from(p: [f32; 2]) -> Self {
    method from (line 245) | fn from(pixels: Pixels) -> Self {
  function all (line 48) | pub fn all(padding: impl Into<Pixels>) -> Padding {
  function top (line 53) | pub fn top(padding: impl Into<Pixels>) -> Padding {
  function bottom (line 58) | pub fn bottom(padding: impl Into<Pixels>) -> Padding {
  function left (line 63) | pub fn left(padding: impl Into<Pixels>) -> Padding {
  function right (line 68) | pub fn right(padding: impl Into<Pixels>) -> Padding {
  function horizontal (line 73) | pub fn horizontal(padding: impl Into<Pixels>) -> Padding {
  function vertical (line 78) | pub fn vertical(padding: impl Into<Pixels>) -> Padding {
  method from (line 239) | fn from(padding: Padding) -> Self {

FILE: core/src/pixels.rs
  type Pixels (line 10) | pub struct Pixels(pub f32);
    constant ZERO (line 14) | pub const ZERO: Self = Self(0.0);
    method from (line 18) | fn from(amount: f32) -> Self {
    method from (line 24) | fn from(amount: u32) -> Self {
    type Output (line 36) | type Output = Pixels;
    method add (line 38) | fn add(self, rhs: Self) -> Self {
    type Output (line 44) | type Output = Pixels;
    method add (line 46) | fn add(self, rhs: f32) -> Self {
    type Output (line 52) | type Output = Pixels;
    method mul (line 54) | fn mul(self, rhs: Self) -> Self {
    type Output (line 60) | type Output = Pixels;
    method mul (line 62) | fn mul(self, rhs: f32) -> Self {
    type Output (line 68) | type Output = Pixels;
    method div (line 70) | fn div(self, rhs: Self) -> Self {
    type Output (line 76) | type Output = Pixels;
    method div (line 78) | fn div(self, rhs: f32) -> Self {
    type Output (line 84) | type Output = Pixels;
    method div (line 86) | fn div(self, rhs: u32) -> Self {
  function from (line 30) | fn from(pixels: Pixels) -> Self {

FILE: core/src/point.rs
  type Point (line 8) | pub struct Point<T = f32> {
    constant ORIGIN (line 18) | pub const ORIGIN: Self = Self::new(0.0, 0.0);
  function new (line 23) | pub const fn new(x: T, y: T) -> Self {
  function distance (line 28) | pub fn distance(&self, to: Self) -> T
  function from (line 43) | fn from([x, y]: [T; 2]) -> Self {
  function from (line 52) | fn from((x, y): (T, T)) -> Self {
  function from (line 58) | fn from(point: Point<T>) -> [T; 2] {
  type Output (line 67) | type Output = Self;
  function add (line 69) | fn add(self, vector: Vector<T>) -> Self {
  function add_assign (line 81) | fn add_assign(&mut self, vector: Vector<T>) {
  type Output (line 91) | type Output = Self;
  function sub (line 93) | fn sub(self, vector: Vector<T>) -> Self {
  function sub_assign (line 105) | fn sub_assign(&mut self, vector: Vector<T>) {
  type Output (line 115) | type Output = Vector<T>;
  function sub (line 117) | fn sub(self, point: Self) -> Vector<T> {
  function fmt (line 126) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function round (line 133) | pub fn round(self) -> Self {
  function snap (line 141) | pub fn snap(self) -> Point<u32> {

FILE: core/src/rectangle.rs
  type Rectangle (line 6) | pub struct Rectangle<T = f32> {
  function with_size (line 26) | pub fn with_size(size: Size<T>) -> Self {
  constant INFINITE (line 38) | pub const INFINITE: Self = Self::new(
  function new (line 45) | pub const fn new(top_left: Point, size: Size) -> Self {
  function with_radius (line 56) | pub fn with_radius(radius: f32) -> Self {
  function with_vertices (line 68) | pub fn with_vertices(
  function center (line 109) | pub fn center(&self) -> Point {
  function center_x (line 115) | pub fn center_x(&self) -> f32 {
  function center_y (line 121) | pub fn center_y(&self) -> f32 {
  function position (line 126) | pub fn position(&self) -> Point {
  function size (line 131) | pub fn size(&self) -> Size {
  function area (line 136) | pub fn area(&self) -> f32 {
  function contains (line 142) | pub fn contains(&self, point: Point) -> bool {
  function distance (line 151) | pub fn distance(&self, point: Point) -> f32 {
  function offset (line 163) | pub fn offset(&self, container: &Rectangle) -> Vector {
  function is_within (line 187) | pub fn is_within(&self, container: &Rectangle) -> bool {
  function intersection (line 195) | pub fn intersection(&self, other: &Rectangle<f32>) -> Option<Rectangle<f...
  function intersects (line 218) | pub fn intersects(&self, other: &Self) -> bool {
  function union (line 223) | pub fn union(&self, other: &Self) -> Self {
  function round (line 242) | pub fn round(self) -> Self {
  function snap (line 255) | pub fn snap(self) -> Option<Rectangle<u32>> {
  function expand (line 271) | pub fn expand(self, padding: impl Into<Padding>) -> Self {
  function shrink (line 283) | pub fn shrink(self, padding: impl Into<Padding>) -> Self {
  function rotate (line 296) | pub fn rotate(self, rotation: Radians) -> Self {
  function zoom (line 308) | pub fn zoom(self, zoom: f32) -> Self {
  function anchor (line 320) | pub fn anchor(
  type Output (line 343) | type Output = Self;
  function mul (line 345) | fn mul(self, scale: f32) -> Self {
  function from (line 356) | fn from(rectangle: Rectangle<u32>) -> Rectangle<f32> {
  type Output (line 370) | type Output = Rectangle<T>;
  function add (line 372) | fn add(self, translation: Vector<T>) -> Self {
  type Output (line 385) | type Output = Rectangle<T>;
  function sub (line 387) | fn sub(self, translation: Vector<T>) -> Self {

FILE: core/src/renderer.rs
  constant CRISP (line 12) | pub const CRISP: bool = cfg!(feature = "crisp");
  type Renderer (line 15) | pub trait Renderer {
    method start_layer (line 17) | fn start_layer(&mut self, bounds: Rectangle);
    method end_layer (line 22) | fn end_layer(&mut self);
    method with_layer (line 27) | fn with_layer(&mut self, bounds: Rectangle, f: impl FnOnce(&mut Self)) {
    method start_transformation (line 34) | fn start_transformation(&mut self, transformation: Transformation);
    method end_transformation (line 39) | fn end_transformation(&mut self);
    method with_transformation (line 42) | fn with_transformation(&mut self, transformation: Transformation, f: i...
    method with_translation (line 49) | fn with_translation(&mut self, translation: Vector, f: impl FnOnce(&mu...
    method fill_quad (line 54) | fn fill_quad(&mut self, quad: Quad, background: impl Into<Background>);
    method allocate_image (line 57) | fn allocate_image(
    method hint (line 71) | fn hint(&mut self, scale_factor: f32);
    method scale_factor (line 74) | fn scale_factor(&self) -> Option<f32>;
    method reset (line 77) | fn reset(&mut self, new_bounds: Rectangle);
    method tick (line 82) | fn tick(&mut self) {}
  type Quad (line 87) | pub struct Quad {
  method default (line 102) | fn default() -> Self {
  type Style (line 114) | pub struct Style {
  method default (line 120) | fn default() -> Self {
  type Headless (line 129) | pub trait Headless {
    method new (line 131) | fn new(settings: Settings, backend: Option<&str>) -> impl Future<Outpu...
    method name (line 139) | fn name(&self) -> String;
    method screenshot (line 143) | fn screenshot(
  type Settings (line 153) | pub struct Settings {
  method default (line 164) | fn default() -> Self {

FILE: core/src/renderer/null.rs
  method start_layer (line 9) | fn start_layer(&mut self, _bounds: Rectangle) {}
  method end_layer (line 11) | fn end_layer(&mut self) {}
  method start_transformation (line 13) | fn start_transformation(&mut self, _transformation: Transformation) {}
  method end_transformation (line 15) | fn end_transformation(&mut self) {}
  method fill_quad (line 17) | fn fill_quad(&mut self, _quad: renderer::Quad, _background: impl Into<Ba...
  method allocate_image (line 19) | fn allocate_image(
  method hint (line 28) | fn hint(&mut self, _scale_factor: f32) {}
  method scale_factor (line 30) | fn scale_factor(&self) -> Option<f32> {
  method reset (line 34) | fn reset(&mut self, _new_bounds: Rectangle) {}
  type Font (line 38) | type Font = Font;
  type Paragraph (line 39) | type Paragraph = ();
  type Editor (line 40) | type Editor = ();
  constant ICON_FONT (line 42) | const ICON_FONT: Font = Font::DEFAULT;
  constant CHECKMARK_ICON (line 43) | const CHECKMARK_ICON: char = '0';
  constant ARROW_DOWN_ICON (line 44) | const ARROW_DOWN_ICON: char = '0';
  constant SCROLL_UP_ICON (line 45) | const SCROLL_UP_ICON: char = '0';
  constant SCROLL_DOWN_ICON (line 46) | const SCROLL_DOWN_ICON: char = '0';
  constant SCROLL_LEFT_ICON (line 47) | const SCROLL_LEFT_ICON: char = '0';
  constant SCROLL_RIGHT_ICON (line 48) | const SCROLL_RIGHT_ICON: char = '0';
  constant ICED_LOGO (line 49) | const ICED_LOGO: char = '0';
  function default_font (line 51) | fn default_font(&self) -> Self::Font {
  function default_size (line 55) | fn default_size(&self) -> Pixels {
  function fill_paragraph (line 59) | fn fill_paragraph(
  function fill_editor (line 68) | fn fill_editor(
  function fill_text (line 77) | fn fill_text(
  type Font (line 88) | type Font = Font;
  function with_text (line 90) | fn with_text(_text: Text<&str>) -> Self {}
  function with_spans (line 92) | fn with_spans<Link>(_text: Text<&[text::Span<'_, Link, Self::Font>], Sel...
  function resize (line 94) | fn resize(&mut self, _new_bounds: Size) {}
  function compare (line 96) | fn compare(&self, _text: Text<()>) -> text::Difference {
  function hint_factor (line 100) | fn hint_factor(&self) -> Option<f32> {
  function size (line 104) | fn size(&self) -> Pixels {
  function font (line 108) | fn font(&self) -> Font {
  function line_height (line 112) | fn line_height(&self) -> text::LineHeight {
  function align_x (line 116) | fn align_x(&self) -> text::Alignment {
  function align_y (line 120) | fn align_y(&self) -> alignment::Vertical {
  function wrapping (line 124) | fn wrapping(&self) -> text::Wrapping {
  function ellipsis (line 128) | fn ellipsis(&self) -> text::Ellipsis {
  function shaping (line 132) | fn shaping(&self) -> text::Shaping {
  function grapheme_position (line 136) | fn grapheme_position(&self, _line: usize, _index: usize) -> Option<Point> {
  function bounds (line 140) | fn bounds(&self) -> Size {
  function min_bounds (line 144) | fn min_bounds(&self) -> Size {
  function hit_test (line 148) | fn hit_test(&self, _point: Point) -> Option<text::Hit> {
  function hit_span (line 152) | fn hit_span(&self, _point: Point) -> Option<usize> {
  function span_bounds (line 156) | fn span_bounds(&self, _index: usize) -> Vec<Rectangle> {
  type Font (line 162) | type Font = Font;
  function with_text (line 164) | fn with_text(_text: &str) -> Self {}
  function is_empty (line 166) | fn is_empty(&self) -> bool {
  function cursor (line 170) | fn cursor(&self) -> text::editor::Cursor {
  function selection (line 177) | fn selection(&self) -> text::editor::Selection {
  function copy (line 181) | fn copy(&self) -> Option<String> {
  function line (line 185) | fn line(&self, _index: usize) -> Option<text::editor::Line<'_>> {
  function line_count (line 189) | fn line_count(&self) -> usize {
  function perform (line 193) | fn perform(&mut self, _action: text::editor::Action) {}
  function move_to (line 195) | fn move_to(&mut self, _cursor: text::editor::Cursor) {}
  function bounds (line 197) | fn bounds(&self) -> Size {
  function hint_factor (line 201) | fn hint_factor(&self) -> Option<f32> {
  function min_bounds (line 205) | fn min_bounds(&self) -> Size {
  function update (line 209) | fn update(
  function highlight (line 221) | fn highlight<H: text::Highlighter>(
  type Handle (line 231) | type Handle = image::Handle;
  function load_image (line 233) | fn load_image(&self, handle: &Self::Handle) -> Result<image::Allocation,...
  function measure_image (line 238) | fn measure_image(&self, _handle: &Self::Handle) -> Option<Size<u32>> {
  function draw_image (line 242) | fn draw_image(&mut self, _image: Image, _bounds: Rectangle, _clip_bounds...
  function measure_svg (line 246) | fn measure_svg(&self, _handle: &svg::Handle) -> Size<u32> {
  function draw_svg (line 250) | fn draw_svg(&mut self, _svg: svg::Svg, _bounds: Rectangle, _clip_bounds:...
  function new (line 254) | async fn new(_settings: renderer::Settings, _backend: Option<&str>) -> O...
  function name (line 261) | fn name(&self) -> String {
  function screenshot (line 265) | fn screenshot(

FILE: core/src/rotation.rs
  type Rotation (line 9) | pub enum Rotation {
    method radians (line 28) | pub fn radians(self) -> Radians {
    method radians_mut (line 35) | pub fn radians_mut(&mut self) -> &mut Radians {
    method degrees (line 42) | pub fn degrees(self) -> Degrees {
    method apply (line 48) | pub fn apply(self, size: Size) -> Size {
    method from (line 63) | fn from(radians: Radians) -> Self {
    method from (line 69) | fn from(radians: f32) -> Self {
  method default (line 57) | fn default() -> Self {

FILE: core/src/settings.rs
  type Settings (line 9) | pub struct Settings {
  method default (line 47) | fn default() -> Self {
  function from (line 62) | fn from(settings: &Settings) -> Self {

FILE: core/src/shadow.rs
  type Shadow (line 5) | pub struct Shadow {

FILE: core/src/shell.rs
  type Shell (line 13) | pub struct Shell<'a, Message> {
  function new (line 25) | pub fn new(messages: &'a mut Vec<Message>) -> Self {
  function is_empty (line 42) | pub fn is_empty(&self) -> bool {
  function publish (line 47) | pub fn publish(&mut self, message: Message) {
  function capture_event (line 55) | pub fn capture_event(&mut self) {
  function event_status (line 61) | pub fn event_status(&self) -> event::Status {
  function is_event_captured (line 67) | pub fn is_event_captured(&self) -> bool {
  function request_redraw (line 72) | pub fn request_redraw(&mut self) {
  function request_redraw_at (line 77) | pub fn request_redraw_at(&mut self, redraw_request: impl Into<window::Re...
  function redraw_request (line 83) | pub fn redraw_request(&self) -> window::RedrawRequest {
  function replace_redraw_request (line 92) | pub fn replace_redraw_request(shell: &mut Self, redraw_request: window::...
  function read_clipboard (line 99) | pub fn read_clipboard(&mut self, kind: clipboard::Kind) {
  function write_clipboard (line 106) | pub fn write_clipboard(&mut self, content: clipboard::Content) {
  function clipboard_mut (line 111) | pub fn clipboard_mut(&mut self) -> &mut Clipboard {
  function request_input_method (line 119) | pub fn request_input_method<T: AsRef<str>>(&mut self, ime: &InputMethod<...
  function input_method (line 125) | pub fn input_method(&self) -> &InputMethod {
  function input_method_mut (line 131) | pub fn input_method_mut(&mut self) -> &mut InputMethod {
  function is_layout_invalid (line 137) | pub fn is_layout_invalid(&self) -> bool {
  function invalidate_layout (line 144) | pub fn invalidate_layout(&mut self) {
  function revalidate_layout (line 150) | pub fn revalidate_layout(&mut self, f: impl FnOnce()) {
  function are_widgets_invalid (line 161) | pub fn are_widgets_invalid(&self) -> bool {
  function invalidate_widgets (line 168) | pub fn invalidate_widgets(&mut self) {
  function merge (line 176) | pub fn merge<B>(&mut self, mut other: Shell<'_, B>, f: impl Fn(B) -> Mes...

FILE: core/src/size.rs
  type Size (line 5) | pub struct Size<T = f32> {
    constant ZERO (line 21) | pub const ZERO: Size = Size::new(0., 0.);
    constant UNIT (line 24) | pub const UNIT: Size = Size::new(1., 1.);
    constant INFINITE (line 27) | pub const INFINITE: Size = Size::new(f32::INFINITY, f32::INFINITY);
    method min (line 30) | pub fn min(self, other: Self) -> Self {
    method max (line 38) | pub fn max(self, other: Self) -> Self {
    method expand (line 46) | pub fn expand(self, other: impl Into<Size>) -> Self {
    method rotate (line 57) | pub fn rotate(self, rotation: Radians) -> Size {
    method ratio (line 68) | pub const fn ratio(self, aspect_ratio: f32) -> Size {
    method from (line 97) | fn from((width, height): (u32, u32)) -> Self {
  function new (line 14) | pub const fn new(width: T, height: T) -> Self {
  function is_void (line 79) | pub fn is_void(&self) -> bool {
  function from (line 85) | fn from([width, height]: [T; 2]) -> Self {
  function from (line 91) | fn from((width, height): (T, T)) -> Self {
  function from (line 103) | fn from(vector: Vector<T>) -> Self {
  function from (line 112) | fn from(size: Size<T>) -> Self {
  function from (line 118) | fn from(size: Size<T>) -> Self {
  type Output (line 127) | type Output = Size<T>;
  function add (line 129) | fn add(self, rhs: Self) -> Self::Output {
  type Output (line 141) | type Output = Size<T>;
  function sub (line 143) | fn sub(self, rhs: Self) -> Self::Output {
  type Output (line 155) | type Output = Size<T>;
  function mul (line 157) | fn mul(self, rhs: T) -> Self::Output {
  type Output (line 169) | type Output = Size<T>;
  function div (line 171) | fn div(self, rhs: T) -> Self::Output {
  type Output (line 183) | type Output = Size<T>;
  function mul (line 185) | fn mul(self, scale: Vector<T>) -> Self::Output {

FILE: core/src/svg.rs
  type Svg (line 12) | pub struct Svg<H = Handle> {
    method from (line 65) | fn from(handle: &Handle) -> Self {
  function new (line 36) | pub fn new(handle: impl Into<Handle>) -> Self {
  function color (line 46) | pub fn color(mut self, color: impl Into<Color>) -> Self {
  function rotation (line 52) | pub fn rotation(mut self, rotation: impl Into<Radians>) -> Self {
  function opacity (line 58) | pub fn opacity(mut self, opacity: impl Into<f32>) -> Self {
  type Handle (line 72) | pub struct Handle {
    method from_path (line 80) | pub fn from_path(path: impl Into<PathBuf>) -> Handle {
    method from_memory (line 89) | pub fn from_memory(bytes: impl Into<Cow<'static, [u8]>>) -> Handle {
    method from_data (line 93) | fn from_data(data: Data) -> Handle {
    method id (line 104) | pub fn id(&self) -> u64 {
    method data (line 109) | pub fn data(&self) -> &Data {
    method from (line 118) | fn from(path: T) -> Handle {
  method hash (line 124) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  type Data (line 131) | pub enum Data {
    method fmt (line 142) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Renderer (line 153) | pub trait Renderer: crate::Renderer {
    method measure_svg (line 155) | fn measure_svg(&self, handle: &Handle) -> Size<u32>;
    method draw_svg (line 158) | fn draw_svg(&mut self, svg: Svg, bounds: Rectangle, clip_bounds: Recta...

FILE: core/src/text.rs
  type Text (line 18) | pub struct Text<Content = String, Font = crate::Font> {
  function with_content (line 66) | pub fn with_content<T>(&self, content: T) -> Text<T, Font> {
  function as_ref (line 89) | pub fn as_ref(&self) -> Text<&str, Font> {
  type Alignment (line 96) | pub enum Alignment {
    method from (line 114) | fn from(alignment: alignment::Horizontal) -> Self {
    method from (line 124) | fn from(alignment: crate::Alignment) -> Self {
  function from (line 134) | fn from(alignment: Alignment) -> Self {
  type Shaping (line 147) | pub enum Shaping {
  method default (line 181) | fn default() -> Self {
  type Wrapping (line 194) | pub enum Wrapping {
  type Ellipsis (line 210) | pub enum Ellipsis {
  type LineHeight (line 226) | pub enum LineHeight {
    method to_absolute (line 236) | pub fn to_absolute(self, text_size: Pixels) -> Pixels {
    method from (line 251) | fn from(factor: f32) -> Self {
    method from (line 257) | fn from(pixels: Pixels) -> Self {
  method default (line 245) | fn default() -> Self {
  method hash (line 263) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Hit (line 279) | pub enum Hit {
    method cursor (line 286) | pub fn cursor(self) -> usize {
  type Difference (line 300) | pub enum Difference {
  type Renderer (line 321) | pub trait Renderer: crate::Renderer {
    constant ICON_FONT (line 332) | const ICON_FONT: Self::Font;
    constant CHECKMARK_ICON (line 337) | const CHECKMARK_ICON: char;
    constant ARROW_DOWN_ICON (line 342) | const ARROW_DOWN_ICON: char;
    constant SCROLL_UP_ICON (line 347) | const SCROLL_UP_ICON: char;
    constant SCROLL_DOWN_ICON (line 352) | const SCROLL_DOWN_ICON: char;
    constant SCROLL_LEFT_ICON (line 357) | const SCROLL_LEFT_ICON: char;
    constant SCROLL_RIGHT_ICON (line 362) | const SCROLL_RIGHT_ICON: char;
    constant ICED_LOGO (line 367) | const ICED_LOGO: char;
    method default_font (line 370) | fn default_font(&self) -> Self::Font;
    method default_size (line 373) | fn default_size(&self) -> Pixels;
    method fill_paragraph (line 377) | fn fill_paragraph(
    method fill_editor (line 387) | fn fill_editor(
    method fill_text (line 397) | fn fill_text(
  type Span (line 408) | pub struct Span<'a, Link = (), Font = crate::Font> {
  type Highlight (line 435) | pub struct Highlight {
  function new (line 444) | pub fn new(fragment: impl IntoFragment<'a>) -> Self {
  function size (line 452) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 458) | pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
  function font (line 464) | pub fn font(mut self, font: impl Into<Font>) -> Self {
  function font_maybe (line 470) | pub fn font_maybe(mut self, font: Option<impl Into<Font>>) -> Self {
  function color (line 476) | pub fn color(mut self, color: impl Into<Color>) -> Self {
  function color_maybe (line 482) | pub fn color_maybe(mut self, color: Option<impl Into<Color>>) -> Self {
  function link (line 488) | pub fn link(mut self, link: impl Into<Link>) -> Self {
  function link_maybe (line 494) | pub fn link_maybe(mut self, link: Option<impl Into<Link>>) -> Self {
  function background (line 500) | pub fn background(self, background: impl Into<Background>) -> Self {
  function background_maybe (line 505) | pub fn background_maybe(mut self, background: Option<impl Into<Backgroun...
  function border (line 526) | pub fn border(self, border: impl Into<Border>) -> Self {
  function border_maybe (line 531) | pub fn border_maybe(mut self, border: Option<impl Into<Border>>) -> Self {
  function padding (line 558) | pub fn padding(mut self, padding: impl Into<Padding>) -> Self {
  function underline (line 564) | pub fn underline(mut self, underline: bool) -> Self {
  function strikethrough (line 570) | pub fn strikethrough(mut self, strikethrough: bool) -> Self {
  function to_static (line 576) | pub fn to_static(self) -> Span<'static, Link, Font> {
  method default (line 593) | fn default() -> Self {
  function from (line 610) | fn from(value: &'a str) -> Self {
  method eq (line 616) | fn eq(&self, other: &Self) -> bool {
  type Fragment (line 629) | pub type Fragment<'a> = Cow<'a, str>;
  type IntoFragment (line 632) | pub trait IntoFragment<'a> {
    method into_fragment (line 634) | fn into_fragment(self) -> Fragment<'a>;
  function into_fragment (line 638) | fn into_fragment(self) -> Fragment<'a> {
  function into_fragment (line 644) | fn into_fragment(self) -> Fragment<'a> {
  function into_fragment (line 650) | fn into_fragment(self) -> Fragment<'a> {
  function into_fragment (line 656) | fn into_fragment(self) -> Fragment<'a> {
  method into_fragment (line 662) | fn into_fragment(self) -> Fragment<'a> {

FILE: core/src/text/editor.rs
  type Editor (line 10) | pub trait Editor: Sized + Default {
    method with_text (line 15) | fn with_text(text: &str) -> Self;
    method is_empty (line 18) | fn is_empty(&self) -> bool;
    method cursor (line 21) | fn cursor(&self) -> Cursor;
    method selection (line 24) | fn selection(&self) -> Selection;
    method copy (line 27) | fn copy(&self) -> Option<String>;
    method line (line 30) | fn line(&self, index: usize) -> Option<Line<'_>>;
    method line_count (line 33) | fn line_count(&self) -> usize;
    method perform (line 36) | fn perform(&mut self, action: Action);
    method move_to (line 39) | fn move_to(&mut self, cursor: Cursor);
    method bounds (line 42) | fn bounds(&self) -> Size;
    method min_bounds (line 46) | fn min_bounds(&self) -> Size;
    method hint_factor (line 49) | fn hint_factor(&self) -> Option<f32>;
    method update (line 52) | fn update(
    method highlight (line 64) | fn highlight<H: Highlighter>(
  type Action (line 74) | pub enum Action {
    method is_edit (line 100) | pub fn is_edit(&self) -> bool {
  type Edit (line 107) | pub enum Edit {
  type Motion (line 126) | pub enum Motion {
    method widen (line 155) | pub fn widen(self) -> Self {
    method direction (line 166) | pub fn direction(&self) -> Direction {
  type Direction (line 186) | pub enum Direction {
  type Selection (line 195) | pub enum Selection {
  type Cursor (line 205) | pub struct Cursor {
  type Position (line 215) | pub struct Position {
  type Line (line 224) | pub struct Line<'a> {
  type LineEnding (line 233) | pub enum LineEnding {
    method as_str (line 249) | pub fn as_str(self) -> &'static str {

FILE: core/src/text/highlighter.rs
  type Highlighter (line 11) | pub trait Highlighter: 'static {
    method new (line 24) | fn new(settings: &Self::Settings) -> Self;
    method update (line 27) | fn update(&mut self, new_settings: &Self::Settings);
    method change_line (line 30) | fn change_line(&mut self, line: usize);
    method highlight_line (line 36) | fn highlight_line(&mut self, line: &str) -> Self::Iterator<'_>;
    method current_line (line 42) | fn current_line(&self) -> usize;
    type Settings (line 50) | type Settings = ();
    type Highlight (line 51) | type Highlight = ();
    type Iterator (line 53) | type Iterator<'a> = std::iter::Empty<(Range<usize>, Self::Highlight)>;
    method new (line 55) | fn new(_settings: &Self::Settings) -> Self {
    method update (line 59) | fn update(&mut self, _new_settings: &Self::Settings) {}
    method change_line (line 61) | fn change_line(&mut self, _line: usize) {}
    method highlight_line (line 63) | fn highlight_line(&mut self, _line: &str) -> Self::Iterator<'_> {
    method current_line (line 67) | fn current_line(&self) -> usize {
  type PlainText (line 47) | pub struct PlainText;
  type Format (line 74) | pub struct Format<Font> {
  method default (line 82) | fn default() -> Self {

FILE: core/src/text/paragraph.rs
  type Paragraph (line 9) | pub trait Paragraph: Sized + Default {
    method with_text (line 14) | fn with_text(text: Text<&str, Self::Font>) -> Self;
    method with_spans (line 17) | fn with_spans<Link>(text: Text<&[Span<'_, Link, Self::Font>], Self::Fo...
    method resize (line 20) | fn resize(&mut self, new_bounds: Size);
    method compare (line 24) | fn compare(&self, text: Text<(), Self::Font>) -> Difference;
    method size (line 27) | fn size(&self) -> Pixels;
    method hint_factor (line 30) | fn hint_factor(&self) -> Option<f32>;
    method font (line 33) | fn font(&self) -> Self::Font;
    method line_height (line 36) | fn line_height(&self) -> LineHeight;
    method align_x (line 39) | fn align_x(&self) -> Alignment;
    method align_y (line 42) | fn align_y(&self) -> alignment::Vertical;
    method wrapping (line 45) | fn wrapping(&self) -> Wrapping;
    method ellipsis (line 48) | fn ellipsis(&self) -> Ellipsis;
    method shaping (line 51) | fn shaping(&self) -> Shaping;
    method bounds (line 54) | fn bounds(&self) -> Size;
    method min_bounds (line 58) | fn min_bounds(&self) -> Size;
    method hit_test (line 62) | fn hit_test(&self, point: Point) -> Option<Hit>;
    method hit_span (line 67) | fn hit_span(&self, point: Point) -> Option<usize>;
    method span_bounds (line 71) | fn span_bounds(&self, index: usize) -> Vec<Rectangle>;
    method grapheme_position (line 74) | fn grapheme_position(&self, line: usize, index: usize) -> Option<Point>;
    method min_width (line 77) | fn min_width(&self) -> f32 {
    method min_height (line 82) | fn min_height(&self) -> f32 {
  type Plain (line 89) | pub struct Plain<P: Paragraph> {
  function new (line 96) | pub fn new(text: Text<String, P::Font>) -> Self {
  function update (line 106) | pub fn update(&mut self, text: Text<&str, P::Font>) -> bool {
  function align_x (line 127) | pub fn align_x(&self) -> Alignment {
  function align_y (line 132) | pub fn align_y(&self) -> alignment::Vertical {
  function min_bounds (line 138) | pub fn min_bounds(&self) -> Size {
  function min_width (line 144) | pub fn min_width(&self) -> f32 {
  function min_height (line 150) | pub fn min_height(&self) -> f32 {
  function raw (line 155) | pub fn raw(&self) -> &P {
  function content (line 160) | pub fn content(&self) -> &str {
  function as_text (line 165) | pub fn as_text(&self) -> Text<&str, P::Font> {

FILE: core/src/theme.rs
  type Theme (line 14) | pub enum Theme {
    constant ALL (line 65) | pub const ALL: &'static [Self] = &[
    method custom (line 91) | pub fn custom(name: impl Into<Cow<'static, str>>, seed: palette::Seed)...
    method custom_with_fn (line 97) | pub fn custom_with_fn(
    method palette (line 106) | pub fn palette(&self) -> &palette::Palette {
    method seed (line 135) | pub fn seed(&self) -> palette::Seed {
    method fmt (line 165) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Custom (line 172) | pub struct Custom {
    method new (line 180) | pub fn new(name: String, seed: palette::Seed) -> Self {
    method with_fn (line 186) | pub fn with_fn(
    method fmt (line 200) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Mode (line 207) | pub enum Mode {
  type Style (line 219) | pub struct Style {
  type Base (line 228) | pub trait Base {
    method default (line 230) | fn default(preference: Mode) -> Self;
    method mode (line 233) | fn mode(&self) -> Mode;
    method base (line 236) | fn base(&self) -> Style;
    method seed (line 242) | fn seed(&self) -> Option<palette::Seed>;
    method name (line 248) | fn name(&self) -> &str;
    method default (line 252) | fn default(preference: Mode) -> Self {
    method mode (line 277) | fn mode(&self) -> Mode {
    method base (line 285) | fn base(&self) -> Style {
    method seed (line 289) | fn seed(&self) -> Option<palette::Seed> {
    method name (line 293) | fn name(&self) -> &str {
  function default (line 323) | pub fn default(theme: &Theme) -> Style {

FILE: core/src/theme/palette.rs
  type Palette (line 8) | pub struct Palette {
    method generate (line 27) | pub fn generate(palette: Seed) -> Self {
  type Pair (line 42) | pub struct Pair {
    method new (line 56) | pub fn new(color: Color, text: Color) -> Self {
  type Background (line 66) | pub struct Background {
    method new (line 87) | pub fn new(base: Color, text: Color) -> Self {
  type Swatch (line 111) | pub struct Swatch {
    method generate (line 122) | pub fn generate(base: Color, background: Color, text: Color) -> Self {
    method derive (line 134) | pub fn derive(base: Color, text: Color) -> Self {
  type Seed (line 152) | pub struct Seed {
    constant LIGHT (line 169) | pub const LIGHT: Self = Self {
    constant DARK (line 179) | pub const DARK: Self = Self {
    constant DRACULA (line 191) | pub const DRACULA: Self = Self {
    constant NORD (line 203) | pub const NORD: Self = Self {
    constant SOLARIZED_LIGHT (line 215) | pub const SOLARIZED_LIGHT: Self = Self {
    constant SOLARIZED_DARK (line 227) | pub const SOLARIZED_DARK: Self = Self {
    constant GRUVBOX_LIGHT (line 239) | pub const GRUVBOX_LIGHT: Self = Self {
    constant GRUVBOX_DARK (line 251) | pub const GRUVBOX_DARK: Self = Self {
    constant CATPPUCCIN_LATTE (line 263) | pub const CATPPUCCIN_LATTE: Self = Self {
    constant CATPPUCCIN_FRAPPE (line 275) | pub const CATPPUCCIN_FRAPPE: Self = Self {
    constant CATPPUCCIN_MACCHIATO (line 287) | pub const CATPPUCCIN_MACCHIATO: Self = Self {
    constant CATPPUCCIN_MOCHA (line 299) | pub const CATPPUCCIN_MOCHA: Self = Self {
    constant TOKYO_NIGHT (line 311) | pub const TOKYO_NIGHT: Self = Self {
    constant TOKYO_NIGHT_STORM (line 323) | pub const TOKYO_NIGHT_STORM: Self = Self {
    constant TOKYO_NIGHT_LIGHT (line 335) | pub const TOKYO_NIGHT_LIGHT: Self = Self {
    constant KANAGAWA_WAVE (line 347) | pub const KANAGAWA_WAVE: Self = Self {
    constant KANAGAWA_DRAGON (line 359) | pub const KANAGAWA_DRAGON: Self = Self {
    constant KANAGAWA_LOTUS (line 371) | pub const KANAGAWA_LOTUS: Self = Self {
    constant MOONFLY (line 383) | pub const MOONFLY: Self = Self {
    constant NIGHTFLY (line 395) | pub const NIGHTFLY: Self = Self {
    constant OXOCARBON (line 407) | pub const OXOCARBON: Self = Self {
    constant FERRA (line 419) | pub const FERRA: Self = Self {
  type Oklch (line 508) | struct Oklch {
  function darken (line 516) | pub fn darken(color: Color, amount: f32) -> Color {
  function lighten (line 535) | pub fn lighten(color: Color, amount: f32) -> Color {
  function deviate (line 553) | pub fn deviate(color: Color, amount: f32) -> Color {
  function readable (line 563) | pub fn readable(background: Color, text: Color) -> Color {
  function is_dark (line 594) | pub fn is_dark(color: Color) -> bool {
  function to_oklch (line 599) | fn to_oklch(color: Color) -> Oklch {
  function from_oklch (line 625) | fn from_oklch(oklch: Oklch) -> Color {

FILE: core/src/time.rs
  function milliseconds (line 8) | pub fn milliseconds(milliseconds: u64) -> Duration {
  function seconds (line 13) | pub fn seconds(seconds: u64) -> Duration {
  function minutes (line 18) | pub fn minutes(minutes: u64) -> Duration {
  function hours (line 23) | pub fn hours(hours: u64) -> Duration {
  function days (line 28) | pub fn days(days: u64) -> Duration {

FILE: core/src/touch.rs
  type Event (line 7) | pub enum Event {
  type Finger (line 23) | pub struct Finger(pub u64);

FILE: core/src/transformation.rs
  type Transformation (line 8) | pub struct Transformation(Mat4);
    constant IDENTITY (line 12) | pub const IDENTITY: Self = Self(Mat4::IDENTITY);
    method orthographic (line 16) | pub fn orthographic(width: u32, height: u32) -> Self{
    method translate (line 25) | pub fn translate(x: f32, y: f32) -> Self {
    method scale (line 30) | pub fn scale(scaling: f32) -> Self {
    method inverse (line 35) | pub fn inverse(self) -> Self {
    method scale_factor (line 40) | pub fn scale_factor(&self) -> f32 {
    method translation (line 45) | pub fn translation(&self) -> Vector {
    method as_ref (line 112) | fn as_ref(&self) -> &[f32; 16] {
  method default (line 51) | fn default() -> Self {
  type Output (line 57) | type Output = Self;
  method mul (line 59) | fn mul(self, rhs: Self) -> Self {
  type Output (line 65) | type Output = Self;
  method mul (line 67) | fn mul(self, transformation: Transformation) -> Self {
  type Output (line 77) | type Output = Self;
  method mul (line 79) | fn mul(self, transformation: Transformation) -> Self {
  type Output (line 89) | type Output = Self;
  method mul (line 91) | fn mul(self, transformation: Transformation) -> Self {
  type Output (line 101) | type Output = Self;
  method mul (line 103) | fn mul(self, transformation: Transformation) -> Self {
  function from (line 118) | fn from(t: Transformation) -> [f32; 16] {
  method from (line 124) | fn from(transformation: Transformation) -> Self {

FILE: core/src/vector.rs
  type Vector (line 3) | pub struct Vector<T = f32> {
    constant ZERO (line 20) | pub const ZERO: Self = Self::new(0.0, 0.0);
    method round (line 23) | pub fn round(self) -> Self {
  function new (line 13) | pub const fn new(x: T, y: T) -> Self {
  type Output (line 35) | type Output = Self;
  function neg (line 37) | fn neg(self) -> Self::Output {
  type Output (line 46) | type Output = Self;
  function add (line 48) | fn add(self, b: Self) -> Self {
  function add_assign (line 57) | fn add_assign(&mut self, b: Self) {
  type Output (line 67) | type Output = Self;
  function sub (line 69) | fn sub(self, b: Self) -> Self {
  function sub_assign (line 78) | fn sub_assign(&mut self, b: Self) {
  type Output (line 88) | type Output = Self;
  function mul (line 90) | fn mul(self, scale: T) -> Self {
  function mul_assign (line 99) | fn mul_assign(&mut self, scale: T) {
  type Output (line 109) | type Output = Self;
  function div (line 111) | fn div(self, scale: T) -> Self {
  function div_assign (line 120) | fn div_assign(&mut self, scale: T) {
  function from (line 127) | fn from([x, y]: [T; 2]) -> Self {
  function from (line 136) | fn from(other: Vector<T>) -> Self {

FILE: core/src/widget.rs
  type Widget (line 37) | pub trait Widget<Message, Theme, Renderer>
    method size (line 42) | fn size(&self) -> Size<Length>;
    method size_hint (line 48) | fn size_hint(&self) -> Size<Length> {
    method layout (line 56) | fn layout(
    method draw (line 64) | fn draw(
    method tag (line 78) | fn tag(&self) -> tree::Tag {
    method state (line 85) | fn state(&self) -> tree::State {
    method children (line 90) | fn children(&self) -> Vec<Tree> {
    method diff (line 95) | fn diff(&self, tree: &mut Tree) {
    method operate (line 100) | fn operate(
    method update (line 112) | fn update(
    method mouse_interaction (line 127) | fn mouse_interaction(
    method overlay (line 139) | fn overlay<'a>(

FILE: core/src/widget/id.rs
  type Id (line 8) | pub struct Id(Internal);
    method new (line 12) | pub const fn new(id: &'static str) -> Self {
    method unique (line 19) | pub fn unique() -> Self {
    method from (line 27) | fn from(value: &'static str) -> Self {
    method from (line 33) | fn from(value: String) -> Self {
  type Internal (line 39) | enum Internal {
  function unique_generates_different_ids (line 49) | fn unique_generates_different_ids() {

FILE: core/src/widget/operation.rs
  type Operation (line 20) | pub trait Operation<T = ()>: Send {
    method traverse (line 27) | fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<T>));
    method container (line 30) | fn container(&mut self, _id: Option<&Id>, _bounds: Rectangle) {}
    method scrollable (line 33) | fn scrollable(
    method focusable (line 44) | fn focusable(&mut self, _id: Option<&Id>, _bounds: Rectangle, _state: ...
    method text_input (line 47) | fn text_input(&mut self, _id: Option<&Id>, _bounds: Rectangle, _state:...
    method text (line 50) | fn text(&mut self, _id: Option<&Id>, _bounds: Rectangle, _text: &str) {}
    method custom (line 53) | fn custom(&mut self, _id: Option<&Id>, _bounds: Rectangle, _state: &mu...
    method finish (line 56) | fn finish(&self) -> Outcome<T> {
  function traverse (line 65) | fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<O>)) {
  function container (line 69) | fn container(&mut self, id: Option<&Id>, bounds: Rectangle) {
  function focusable (line 73) | fn focusable(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut ...
  function scrollable (line 77) | fn scrollable(
  function text_input (line 89) | fn text_input(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut...
  function text (line 93) | fn text(&mut self, id: Option<&Id>, bounds: Rectangle, text: &str) {
  function custom (line 97) | fn custom(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut dyn...
  function finish (line 101) | fn finish(&self) -> Outcome<O> {
  type Outcome (line 107) | pub enum Outcome<T> {
  function fmt (line 122) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function black_box (line 132) | pub fn black_box<'a, T, O>(operation: &'a mut dyn Operation<T>) -> impl ...
  function map (line 191) | pub fn map<A, B>(
  function then (line 324) | pub fn then<A, B, O>(operation: impl Operation<A> + 'static, f: fn(A) ->...
  function scope (line 403) | pub fn scope<T: 'static>(target: Id, operation: impl Operation<T> + 'sta...

FILE: core/src/widget/operation/focusable.rs
  type Focusable (line 7) | pub trait Focusable {
    method is_focused (line 9) | fn is_focused(&self) -> bool;
    method focus (line 12) | fn focus(&mut self);
    method unfocus (line 15) | fn unfocus(&mut self);
  type Count (line 20) | pub struct Count {
  function focus (line 29) | pub fn focus<T>(target: Id) -> impl Operation<T> {
  function unfocus (line 55) | pub fn unfocus<T>() -> impl Operation<T> {
  function count (line 73) | pub fn count() -> impl Operation<Count> {
  function focus_previous (line 104) | pub fn focus_previous<T>() -> impl Operation<T>
  function focus_next (line 142) | pub fn focus_next<T>() -> impl Operation<T>
  function find_focused (line 173) | pub fn find_focused() -> impl Operation<Id> {
  function is_focused (line 204) | pub fn is_focused(target: Id) -> impl Operation<bool> {

FILE: core/src/widget/operation/scrollable.rs
  type Scrollable (line 6) | pub trait Scrollable {
    method snap_to (line 8) | fn snap_to(&mut self, offset: RelativeOffset<Option<f32>>);
    method scroll_to (line 11) | fn scroll_to(&mut self, offset: AbsoluteOffset<Option<f32>>);
    method scroll_by (line 14) | fn scroll_by(&mut self, offset: AbsoluteOffset, bounds: Rectangle, con...
  function snap_to (line 19) | pub fn snap_to<T>(target: Id, offset: RelativeOffset<Option<f32>>) -> im...
  function scroll_to (line 49) | pub fn scroll_to<T>(target: Id, offset: AbsoluteOffset<Option<f32>>) -> ...
  function scroll_by (line 79) | pub fn scroll_by<T>(target: Id, offset: AbsoluteOffset) -> impl Operatio...
  type AbsoluteOffset (line 109) | pub struct AbsoluteOffset<T = f32> {
  function from (line 117) | fn from(offset: AbsoluteOffset) -> Self {
  type RelativeOffset (line 129) | pub struct RelativeOffset<T = f32> {
    constant START (line 138) | pub const START: Self = Self { x: 0.0, y: 0.0 };
    constant END (line 141) | pub const END: Self = Self { x: 1.0, y: 1.0 };
  function from (line 145) | fn from(offset: RelativeOffset) -> Self {

FILE: core/src/widget/operation/text_input.rs
  type TextInput (line 7) | pub trait TextInput {
    method text (line 11) | fn text(&self) -> &str;
    method move_cursor_to_front (line 14) | fn move_cursor_to_front(&mut self);
    method move_cursor_to_end (line 17) | fn move_cursor_to_end(&mut self);
    method move_cursor_to (line 20) | fn move_cursor_to(&mut self, position: usize);
    method select_all (line 23) | fn select_all(&mut self);
    method select_range (line 25) | fn select_range(&mut self, start: usize, end: usize);
  function move_cursor_to_front (line 30) | pub fn move_cursor_to_front<T>(target: Id) -> impl Operation<T> {
  function move_cursor_to_end (line 55) | pub fn move_cursor_to_end<T>(target: Id) -> impl Operation<T> {
  function move_cursor_to (line 80) | pub fn move_cursor_to<T>(target: Id, position: usize) -> impl Operation<...
  function select_all (line 105) | pub fn select_all<T>(target: Id) -> impl Operation<T> {
  function select_range (line 129) | pub fn select_range<T>(target: Id, start: usize, end: usize) -> impl Ope...

FILE: core/src/widget/text.rs
  type Text (line 57) | pub struct Text<'a, Theme, Renderer>
  function new (line 73) | pub fn new(fragment: impl text::IntoFragment<'a>) -> Self {
  function size (line 82) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 88) | pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
  function font (line 96) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function font_maybe (line 104) | pub fn font_maybe(mut self, font: Option<impl Into<Renderer::Font>>) -> ...
  function width (line 110) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 116) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function center (line 122) | pub fn center(self) -> Self {
  function align_x (line 128) | pub fn align_x(mut self, alignment: impl Into<text::Alignment>) -> Self {
  function align_y (line 134) | pub fn align_y(mut self, alignment: impl Into<alignment::Vertical>) -> S...
  function shaping (line 140) | pub fn shaping(mut self, shaping: Shaping) -> Self {
  function wrapping (line 146) | pub fn wrapping(mut self, wrapping: Wrapping) -> Self {
  function ellipsis (line 152) | pub fn ellipsis(mut self, ellipsis: Ellipsis) -> Self {
  function style (line 158) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function color (line 167) | pub fn color(self, color: impl Into<Color>) -> Self
  function color_maybe (line 175) | pub fn color_maybe(self, color: Option<impl Into<Color>>) -> Self
  function class (line 186) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  type State (line 193) | pub type State<P> = paragraph::Plain<P>;
  function tag (line 200) | fn tag(&self) -> tree::Tag {
  function state (line 204) | fn state(&self) -> tree::State {
  function size (line 208) | fn size(&self) -> Size<Length> {
  function layout (line 215) | fn layout(
  function draw (line 230) | fn draw(
  function operate (line 253) | fn operate(
  type Format (line 270) | pub struct Format<Font> {
  method default (line 284) | fn default() -> Self {
  function layout (line 301) | pub fn layout<Renderer>(
  function draw (line 336) | pub fn draw<Renderer>(
  function from (line 366) | fn from(text: Text<'a, Theme, Renderer>) -> Element<'a, Message, Theme, ...
  function from (line 376) | fn from(content: &'a str) -> Self {
  function from (line 386) | fn from(content: &'a str) -> Self {
  type Style (line 393) | pub struct Style {
  type Catalog (line 401) | pub trait Catalog: Sized {
    method default (line 406) | fn default<'a>() -> Self::Class<'a>;
    method style (line 409) | fn style(&self, item: &Self::Class<'_>) -> Style;
    type Class (line 418) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 420) | fn default<'a>() -> Self::Class<'a> {
    method style (line 424) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 415) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function default (line 430) | pub fn default(_theme: &Theme) -> Style {
  function base (line 435) | pub fn base(theme: &Theme) -> Style {
  function primary (line 442) | pub fn primary(theme: &Theme) -> Style {
  function secondary (line 449) | pub fn secondary(theme: &Theme) -> Style {
  function success (line 456) | pub fn success(theme: &Theme) -> Style {
  function warning (line 463) | pub fn warning(theme: &Theme) -> Style {
  function danger (line 470) | pub fn danger(theme: &Theme) -> Style {

FILE: core/src/widget/tree.rs
  type Tree (line 12) | pub struct Tree {
    method empty (line 25) | pub fn empty() -> Self {
    method new (line 34) | pub fn new<'a, Message, Theme, Renderer>(
    method diff (line 57) | pub fn diff<'a, Message, Theme, Renderer>(
    method diff_children (line 71) | pub fn diff_children<'a, Message, Theme, Renderer>(
    method diff_children_custom (line 86) | pub fn diff_children_custom<T>(
  function diff_children_custom_with_search (line 112) | pub fn diff_children_custom_with_search<T>(
  type Tag (line 184) | pub struct Tag(any::TypeId);
    method of (line 188) | pub fn of<T>() -> Self
    method stateless (line 196) | pub fn stateless() -> Self {
  type State (line 202) | pub enum State {
    method new (line 212) | pub fn new<T>(state: T) -> Self
    method downcast_ref (line 223) | pub fn downcast_ref<T>(&self) -> &T
    method downcast_mut (line 237) | pub fn downcast_mut<T>(&mut self) -> &mut T
    method fmt (line 249) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/src/window/direction.rs
  type Direction (line 3) | pub enum Direction {

FILE: core/src/window/event.rs
  type Event (line 8) | pub enum Event {

FILE: core/src/window/icon.rs
  function from_rgba (line 7) | pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Icon,...
  type Icon (line 35) | pub struct Icon {
    method into_raw (line 42) | pub fn into_raw(self) -> (Vec<u8>, Size<u32>) {
    method fmt (line 48) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Error (line 58) | pub enum Error {

FILE: core/src/window/id.rs
  type Id (line 8) | pub struct Id(u64);
    method unique (line 14) | pub fn unique() -> Id {
    method fmt (line 20) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: core/src/window/level.rs
  type Level (line 7) | pub enum Level {

FILE: core/src/window/mode.rs
  type Mode (line 3) | pub enum Mode {

FILE: core/src/window/position.rs
  type Position (line 5) | pub enum Position {

FILE: core/src/window/redraw_request.rs
  type RedrawRequest (line 5) | pub enum RedrawRequest {
    method from (line 17) | fn from(time: Instant) -> Self {
  function ordering (line 28) | fn ordering() {

FILE: core/src/window/screenshot.rs
  type Screenshot (line 10) | pub struct Screenshot {
    method new (line 34) | pub fn new(rgba: impl Into<Bytes>, size: Size<u32>, scale_factor: f32)...
    method crop (line 44) | pub fn crop(&self, region: Rectangle<u32>) -> Result<Self, CropError> {
    method as_ref (line 83) | fn as_ref(&self) -> &[u8] {
  method fmt (line 21) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method from (line 89) | fn from(screenshot: Screenshot) -> Self {
  type CropError (line 96) | pub enum CropError {

FILE: core/src/window/settings.rs
  type Settings (line 34) | pub struct Settings {
  method default (line 104) | fn default() -> Self {

FILE: core/src/window/settings/linux.rs
  type PlatformSpecific (line 5) | pub struct PlatformSpecific {

FILE: core/src/window/settings/macos.rs
  type PlatformSpecific (line 5) | pub struct PlatformSpecific {

FILE: core/src/window/settings/other.rs
  type PlatformSpecific (line 3) | pub struct PlatformSpecific;

FILE: core/src/window/settings/wasm.rs
  type PlatformSpecific (line 5) | pub struct PlatformSpecific {
  method default (line 16) | fn default() -> Self {

FILE: core/src/window/settings/windows.rs
  type PlatformSpecific (line 5) | pub struct PlatformSpecific {
  method default (line 25) | fn default() -> Self {
  type CornerPreference (line 38) | pub enum CornerPreference {

FILE: core/src/window/user_attention.rs
  type UserAttention (line 10) | pub enum UserAttention {

FILE: debug/src/lib.rs
  type Metadata (line 11) | pub struct Metadata {
  type Primitive (line 18) | pub enum Primitive {
  type Command (line 27) | pub enum Command {
  function enable (line 32) | pub fn enable() {
  function disable (line 36) | pub fn disable() {
  function init (line 40) | pub fn init(metadata: Metadata) {
  function quit (line 45) | pub fn quit() -> bool {
  function theme_changed (line 49) | pub fn theme_changed(f: impl FnOnce() -> Option<palette::Seed>) {
  function tasks_spawned (line 53) | pub fn tasks_spawned(amount: usize) {
  function subscriptions_tracked (line 57) | pub fn subscriptions_tracked(amount: usize) {
  function layers_rendered (line 61) | pub fn layers_rendered(amount: impl FnOnce() -> usize) {
  function boot (line 65) | pub fn boot() -> Span {
  function update (line 69) | pub fn update(message: &impl std::fmt::Debug) -> Span {
  function view (line 73) | pub fn view(window: window::Id) -> Span {
  function layout (line 77) | pub fn layout(window: window::Id) -> Span {
  function interact (line 81) | pub fn interact(window: window::Id) -> Span {
  function draw (line 85) | pub fn draw(window: window::Id) -> Span {
  function prepare (line 89) | pub fn prepare(primitive: Primitive) -> Span {
  function render (line 93) | pub fn render(primitive: Primitive) -> Span {
  function present (line 97) | pub fn present(window: window::Id) -> Span {
  function time (line 101) | pub fn time(name: impl Into<String>) -> Span {
  function time_with (line 105) | pub fn time_with<T>(name: impl Into<String>, f: impl FnOnce() -> T) -> T {
  function commands (line 113) | pub fn commands() -> Subscription<Command> {
  function hot (line 117) | pub fn hot<O>(f: impl FnOnce() -> O) -> O {
  function on_hotpatch (line 121) | pub fn on_hotpatch(f: impl Fn() + Send + Sync + 'static) {
  function is_stale (line 125) | pub fn is_stale() -> bool {
  function init (line 147) | pub fn init(metadata: Metadata) {
  function quit (line 157) | pub fn quit() -> bool {
  function theme_changed (line 167) | pub fn theme_changed(f: impl FnOnce() -> Option<palette::Seed>) {
  function tasks_spawned (line 179) | pub fn tasks_spawned(amount: usize) {
  function subscriptions_tracked (line 183) | pub fn subscriptions_tracked(amount: usize) {
  function layers_rendered (line 187) | pub fn layers_rendered(amount: impl FnOnce() -> usize) {
  function boot (line 191) | pub fn boot() -> Span {
  function update (line 195) | pub fn update(message: &impl std::fmt::Debug) -> Span {
  function view (line 223) | pub fn view(window: window::Id) -> Span {
  function layout (line 227) | pub fn layout(window: window::Id) -> Span {
  function interact (line 231) | pub fn interact(window: window::Id) -> Span {
  function draw (line 235) | pub fn draw(window: window::Id) -> Span {
  function prepare (line 239) | pub fn prepare(primitive: Primitive) -> Span {
  function render (line 243) | pub fn render(primitive: Primitive) -> Span {
  function present (line 247) | pub fn present(window: window::Id) -> Span {
  function time (line 251) | pub fn time(name: impl Into<String>) -> Span {
  function enable (line 255) | pub fn enable() {
  function disable (line 259) | pub fn disable() {
  function commands (line 263) | pub fn commands() -> Subscription<Command> {
  function span (line 280) | fn span(span: span::Stage) -> Span {
  function to_primitive (line 289) | fn to_primitive(primitive: Primitive) -> present::Primitive {
  function log (line 299) | fn log(event: client::Event) {
  type Span (line 306) | pub struct Span {
    method finish (line 312) | pub fn finish(self) {
    method finish (line 405) | pub fn finish(self) {}
  function enable (line 340) | pub fn enable() {}
  function disable (line 341) | pub fn disable() {}
  function init (line 343) | pub fn init(_metadata: Metadata) {}
  function quit (line 345) | pub fn quit() -> bool {
  function theme_changed (line 349) | pub fn theme_changed(_f: impl FnOnce() -> Option<palette::Seed>) {}
  function tasks_spawned (line 351) | pub fn tasks_spawned(_amount: usize) {}
  function subscriptions_tracked (line 353) | pub fn subscriptions_tracked(_amount: usize) {}
  function layers_rendered (line 355) | pub fn layers_rendered(_amount: impl FnOnce() -> usize) {}
  function boot (line 357) | pub fn boot() -> Span {
  function update (line 361) | pub fn update(_message: &impl std::fmt::Debug) -> Span {
  function view (line 365) | pub fn view(_window: window::Id) -> Span {
  function layout (line 369) | pub fn layout(_window: window::Id) -> Span {
  function interact (line 373) | pub fn interact(_window: window::Id) -> Span {
  function draw (line 377) | pub fn draw(_window: window::Id) -> Span {
  function prepare (line 381) | pub fn prepare(_primitive: Primitive) -> Span {
  function render (line 385) | pub fn render(_primitive: Primitive) -> Span {
  function present (line 389) | pub fn present(_window: window::Id) -> Span {
  function time (line 393) | pub fn time(_name: impl Into<String>) -> Span {
  function commands (line 397) | pub fn commands() -> Subscription<Command> {
  type Span (line 402) | pub struct Span;
    method finish (line 312) | pub fn finish(self) {
    method finish (line 405) | pub fn finish(self) {}
  function init (line 421) | pub fn init() {
  function call (line 437) | pub fn call<O>(f: impl FnOnce() -> O) -> O {
  function on_hotpatch (line 462) | pub fn on_hotpatch(f: impl Fn() + Send + Sync + 'static) {
  function is_stale (line 466) | pub fn is_stale() -> bool {
  function init (line 473) | pub fn init() {}
  function call (line 475) | pub fn call<O>(f: impl FnOnce() -> O) -> O {
  function on_hotpatch (line 479) | pub fn on_hotpatch(_f: impl Fn()) {}
  function is_stale (line 481) | pub fn is_stale() -> bool {

FILE: devtools/src/comet.rs
  constant COMPATIBLE_REVISION (line 5) | pub const COMPATIBLE_REVISION: &str = "fbef808eed51562f0ea601d8fc7c715be...
  function launch (line 7) | pub fn launch() -> Task<launch::Result> {
  function install (line 48) | pub fn install() -> Task<install::Result> {
  type Result (line 97) | pub type Result = std::result::Result<(), Error>;
  type Error (line 100) | pub enum Error {
    method from (line 107) | fn from(error: io::Error) -> Self {
    method from (line 133) | fn from(error: io::Error) -> Self {
  type Result (line 118) | pub type Result = std::result::Result<Event, Error>;
  type Event (line 121) | pub enum Event {
  type Error (line 127) | pub enum Error {
    method from (line 107) | fn from(error: io::Error) -> Self {
    method from (line 133) | fn from(error: io::Error) -> Self {

FILE: devtools/src/lib.rs
  function attach (line 31) | pub fn attach<P: Program + 'static>(program: P) -> Attach<P> {
  type Attach (line 37) | pub struct Attach<P> {
  type State (line 47) | type State = DevTools<P>;
  type Message (line 48) | type Message = Event<P>;
  type Theme (line 49) | type Theme = P::Theme;
  type Renderer (line 50) | type Renderer = P::Renderer;
  type Executor (line 51) | type Executor = P::Executor;
  method name (line 53) | fn name() -> &'static str {
  method settings (line 57) | fn settings(&self) -> Settings {
  method window (line 61) | fn window(&self) -> Option<window::Settings> {
  method boot (line 65) | fn boot(&self) -> (Self::State, Task<Self::Message>) {
  method update (line 75) | fn update(&self, state: &mut Self::State, message: Self::Message) -> Tas...
  method view (line 79) | fn view<'a>(
  method title (line 87) | fn title(&self, state: &Self::State, window: window::Id) -> String {
  method subscription (line 91) | fn subscription(&self, state: &Self::State) -> Subscription<Self::Messag...
  method theme (line 95) | fn theme(&self, state: &Self::State, window: window::Id) -> Option<Self:...
  method style (line 99) | fn style(&self, state: &Self::State, theme: &Self::Theme) -> theme::Style {
  method scale_factor (line 103) | fn scale_factor(&self, state: &Self::State, window: window::Id) -> f32 {
  type DevTools (line 109) | pub struct DevTools<P>
  type Message (line 120) | pub enum Message {
  type Mode (line 129) | enum Mode {
  type Setup (line 134) | enum Setup {
  type Goal (line 139) | enum Goal {
  function new (line 149) | pub fn new(state: P::State) -> (Self, Task<Message>) {
  function title (line 165) | pub fn title(&self, program: &P, window: window::Id) -> String {
  function update (line 169) | pub fn update(&mut self, program: &P, event: Event<P>) -> Task<Event<P>> {
  function view (line 291) | pub fn view(
  function subscription (line 358) | pub fn subscription(&self, program: &P) -> Subscription<Event<P>> {
  function theme (line 377) | pub fn theme(&self, program: &P, window: window::Id) -> Option<P::Theme> {
  function style (line 381) | pub fn style(&self, program: &P, theme: &P::Theme) -> theme::Style {
  function scale_factor (line 385) | pub fn scale_factor(&self, program: &P, window: window::Id) -> f32 {
  function state (line 389) | pub fn state(&self) -> &P::State {
  type Event (line 394) | pub enum Event<P>
  function fmt (line 409) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function setup (line 419) | fn setup<Renderer>(goal: &Goal) -> Element<'_, Message, Theme, Renderer>
  function installation (line 507) | fn installation<'a, Renderer>(logs: &'a [String]) -> Element<'a, Message...
  function inline_code (line 533) | fn inline_code<'a, Renderer>(

FILE: devtools/src/time_machine.rs
  type TimeMachine (line 4) | pub struct TimeMachine<P>
  function new (line 18) | pub fn new() -> Self {
  function is_rewinding (line 25) | pub fn is_rewinding(&self) -> bool {
  function push (line 29) | pub fn push(&mut self, message: &P::Message) {
  function rewind (line 33) | pub fn rewind(&mut self, program: &P, message: usize) {
  function go_to_present (line 47) | pub fn go_to_present(&mut self) {
  function state (line 52) | pub fn state(&self) -> Option<&P::State> {
  type TimeMachine (line 58) | pub struct TimeMachine<P>
  function new (line 70) | pub fn new() -> Self {
  function is_rewinding (line 76) | pub fn is_rewinding(&self) -> bool {
  function push (line 80) | pub fn push(&mut self, _message: &P::Message) {}
  function rewind (line 82) | pub fn rewind(&mut self, _program: &P, _message: usize) {}
  function go_to_present (line 84) | pub fn go_to_present(&mut self) {}
  function state (line 86) | pub fn state(&self) -> Option<&P::State> {

FILE: docs/release_summary.py
  function get_merged_prs (line 4) | def get_merged_prs(repo, milestone, token):
  function categorize_prs (line 30) | def categorize_prs(prs):
  function get_authors (line 44) | def get_authors(prs):
  function main (line 50) | def main():

FILE: examples/arc/src/main.rs
  function main (line 8) | pub fn main() -> iced::Result {
  type Arc (line 15) | struct Arc {
    method new (line 26) | fn new() -> Self {
    method update (line 33) | fn update(&mut self, _: Message) {
    method view (line 37) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 41) | fn subscription(&self) -> Subscription<Message> {
    type State (line 47) | type State = ();
    method draw (line 49) | fn draw(
  type Message (line 21) | enum Message {

FILE: examples/bezier_tool/src/main.rs
  function main (line 5) | pub fn main() -> iced::Result {
  type Example (line 12) | struct Example {
    method update (line 24) | fn update(&mut self, message: Message) {
    method view (line 37) | fn view(&self) -> Element<'_, Message> {
  type Message (line 18) | enum Message {
  type State (line 62) | pub struct State {
    method view (line 67) | pub fn view<'a>(&'a self, curves: &'a [Curve]) -> Element<'a, Curve> {
    method request_redraw (line 77) | pub fn request_redraw(&mut self) {
  type Bezier (line 82) | struct Bezier<'a> {
  type State (line 88) | type State = Option<Pending>;
    method view (line 67) | pub fn view<'a>(&'a self, curves: &'a [Curve]) -> Element<'a, Curve> {
    method request_redraw (line 77) | pub fn request_redraw(&mut self) {
  function update (line 90) | fn update(
  function draw (line 136) | fn draw(
  function mouse_interaction (line 162) | fn mouse_interaction(
  type Curve (line 177) | pub struct Curve {
    method draw_all (line 184) | fn draw_all(curves: &[Curve], frame: &mut Frame, theme: &Theme) {
  type Pending (line 202) | enum Pending {
    method draw (line 208) | fn draw(

FILE: examples/changelog/src/changelog.rs
  type Changelog (line 13) | pub struct Changelog {
    method new (line 24) | pub fn new() -> Self {
    method list (line 36) | pub async fn list() -> Result<(Self, Vec<Contribution>), Error> {
    method save (line 126) | pub async fn save(self) -> Result<(), Error> {
    method len (line 147) | pub fn len(&self) -> usize {
    method entries (line 151) | pub fn entries(&self) -> impl Iterator<Item = u64> + '_ {
    method push (line 155) | pub fn push(&mut self, entry: Entry) {
    method fmt (line 192) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Entry (line 228) | pub struct Entry {
    method new (line 236) | pub fn new(title: &str, category: Category, pull_request: &PullRequest...
  type Category (line 253) | pub enum Category {
    constant ALL (line 261) | pub const ALL: &'static [Self] = &[Self::Added, Self::Changed, Self::F...
    method guess (line 263) | pub fn guess(label: &str) -> Option<Self> {
    method fmt (line 274) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Contribution (line 285) | pub struct Contribution {
    method list (line 291) | pub async fn list() -> Result<Vec<Contribution>, Error> {
  type PullRequest (line 330) | pub struct PullRequest {
    method fetch (line 340) | pub async fn fetch(contribution: Contribution) -> Result<Self, Error> {
  type Error (line 391) | pub enum Error {
    method from (line 409) | fn from(error: io::Error) -> Self {
    method from (line 415) | fn from(error: reqwest::Error) -> Self {

FILE: examples/changelog/src/icon.rs
  constant FONT_BYTES (line 4) | pub const FONT_BYTES: &[u8] = include_bytes!("../fonts/changelog-icons.t...
  constant FONT (line 6) | const FONT: Font = Font::with_name("changelog-icons");
  function copy (line 8) | pub fn copy() -> Text<'static> {

FILE: examples/changelog/src/main.rs
  function main (line 12) | pub fn main() -> iced::Result {
  type Generator (line 20) | enum Generator {
    method new (line 56) | fn new() -> (Self, Task<Message>) {
    method update (line 63) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 211) | fn view(&self) -> Element<'_, Message> {
    method theme (line 347) | fn theme(&self) -> Theme {
  type State (line 32) | enum State {
  type Message (line 43) | enum Message {

FILE: examples/checkbox/src/main.rs
  constant ICON_FONT (line 4) | const ICON_FONT: Font = Font::new("icons");
  function main (line 6) | pub fn main() -> iced::Result {
  type Example (line 13) | struct Example {
    method update (line 27) | fn update(&mut self, message: Message) {
    method view (line 41) | fn view(&self) -> Element<'_, Message> {
  type Message (line 20) | enum Message {

FILE: examples/clock/src/main.rs
  function main (line 11) | pub fn main() -> iced::Result {
  type Clock (line 20) | struct Clock {
    method new (line 31) | fn new() -> Self {
    method update (line 38) | fn update(&mut self, message: Message) {
    method view (line 51) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 57) | fn subscription(&self) -> Subscription<Message> {
    method theme (line 61) | fn theme(&self) -> Theme {
    type State (line 67) | type State = ();
    method draw (line 69) | fn draw(
  type Message (line 26) | enum Message {
  function hand_rotation (line 188) | fn hand_rotation(n: u32, total: u32) -> Degrees {

FILE: examples/color_palette/src/main.rs
  function main (line 12) | pub fn main() -> iced::Result {
  type ColorPalette (line 24) | pub struct ColorPalette {
    method update (line 45) | fn update(&mut self, message: Message) {
    method view (line 58) | fn view(&self) -> Element<'_, Message> {
    method theme (line 82) | fn theme(&self) -> iced::Theme {
  type Message (line 35) | pub enum Message {
  type Theme (line 98) | struct Theme {
    method new (line 106) | pub fn new(base: impl Into<Color>) -> Theme {
    method len (line 140) | pub fn len(&self) -> usize {
    method colors (line 144) | pub fn colors(&self) -> impl Iterator<Item = &Color> {
    method view (line 151) | pub fn view(&self) -> Element<'_, Message> {
    method draw (line 155) | fn draw(&self, frame: &mut Frame, text_color: Color) {
    type State (line 246) | type State = ();
    method draw (line 248) | fn draw(
  method default (line 267) | fn default() -> Self {
  function color_hex_string (line 272) | fn color_hex_string(color: &Color) -> String {
  type ColorPicker (line 282) | struct ColorPicker<C: ColorSpace> {
  type ColorSpace (line 286) | trait ColorSpace: Sized {
    constant LABEL (line 287) | const LABEL: &'static str;
    constant COMPONENT_RANGES (line 288) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3];
    method new (line 290) | fn new(a: f32, b: f32, c: f32) -> Self;
    method components (line 292) | fn components(&self) -> [f32; 3];
    method to_string (line 294) | fn to_string(&self) -> String;
    constant LABEL (line 324) | const LABEL: &'static str = "RGB";
    constant COMPONENT_RANGES (line 325) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] = [0.0..=1.0, 0.0..=1...
    method new (line 327) | fn new(r: f32, g: f32, b: f32) -> Self {
    method components (line 331) | fn components(&self) -> [f32; 3] {
    method to_string (line 335) | fn to_string(&self) -> String {
    constant LABEL (line 346) | const LABEL: &'static str = "HSL";
    constant COMPONENT_RANGES (line 347) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] = [0.0..=360.0, 0.0.....
    method new (line 349) | fn new(hue: f32, saturation: f32, lightness: f32) -> Self {
    method components (line 353) | fn components(&self) -> [f32; 3] {
    method to_string (line 361) | fn to_string(&self) -> String {
    constant LABEL (line 372) | const LABEL: &'static str = "HSV";
    constant COMPONENT_RANGES (line 373) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] = [0.0..=360.0, 0.0.....
    method new (line 375) | fn new(hue: f32, saturation: f32, value: f32) -> Self {
    method components (line 379) | fn components(&self) -> [f32; 3] {
    method to_string (line 387) | fn to_string(&self) -> String {
    constant LABEL (line 398) | const LABEL: &'static str = "HWB";
    constant COMPONENT_RANGES (line 399) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] = [0.0..=360.0, 0.0.....
    method new (line 401) | fn new(hue: f32, whiteness: f32, blackness: f32) -> Self {
    method components (line 405) | fn components(&self) -> [f32; 3] {
    method to_string (line 413) | fn to_string(&self) -> String {
    constant LABEL (line 424) | const LABEL: &'static str = "Lab";
    constant COMPONENT_RANGES (line 425) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] =
    method new (line 428) | fn new(l: f32, a: f32, b: f32) -> Self {
    method components (line 432) | fn components(&self) -> [f32; 3] {
    method to_string (line 436) | fn to_string(&self) -> String {
    constant LABEL (line 442) | const LABEL: &'static str = "Lch";
    constant COMPONENT_RANGES (line 443) | const COMPONENT_RANGES: [RangeInclusive<f64>; 3] = [0.0..=100.0, 0.0.....
    method new (line 445) | fn new(l: f32, chroma: f32, hue: f32) -> Self {
    method components (line 449) | fn components(&self) -> [f32; 3] {
    method to_string (line 453) | fn to_string(&self) -> String {
  function view (line 298) | fn view(&self, color: C) -> Element<'_, C> {
  function to_rgb (line 463) | fn to_rgb(color: Color) -> Rgb {
  function to_color (line 472) | fn to_color(rgb: Rgb) -> Color {

FILE: examples/combo_box/src/main.rs
  function main (line 4) | pub fn main() -> iced::Result {
  type Example (line 8) | struct Example {
    method new (line 22) | fn new() -> Self {
    method update (line 30) | fn update(&mut self, message: Message) {
    method view (line 48) | fn view(&self) -> Element<'_, Message> {
  type Message (line 15) | enum Message {
  method default (line 74) | fn default() -> Self {
  type Language (line 80) | pub enum Language {
    constant ALL (line 94) | const ALL: [Language; 9] = [
    method hello (line 106) | fn hello(&self) -> &str {
    method fmt (line 122) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: examples/counter/src/main.rs
  function main (line 4) | pub fn main() -> iced::Result {
  type Counter (line 9) | struct Counter {
    method update (line 20) | fn update(&mut self, message: Message) {
    method view (line 31) | fn view(&self) -> Column<'_, Message> {
  type Message (line 14) | enum Message {
  function it_counts (line 48) | fn it_counts() -> Result<(), Error> {

FILE: examples/custom_quad/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Example (line 10) | struct Example {
    method new (line 32) | fn new() -> Self {
    method update (line 45) | fn update(&mut self, message: Message) {
    method view (line 77) | fn view(&self) -> Element<'_, Message> {
  type Message (line 19) | enum Message {
  method default (line 123) | fn default() -> Self {
  type CustomQuad (line 136) | pub struct CustomQuad {
    method new (line 145) | pub fn new(
    method size (line 166) | fn size(&self) -> Size<Length> {
    method layout (line 173) | fn layout(
    method draw (line 182) | fn draw(
  function from (line 209) | fn from(circle: CustomQuad) -> Self {

FILE: examples/custom_shader/src/main.rs
  function main (line 11) | fn main() -> iced::Result {
  type IcedCubes (line 17) | struct IcedCubes {
    method new (line 32) | fn new() -> Self {
    method update (line 39) | fn update(&mut self, message: Message) {
    method view (line 59) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 129) | fn subscription(&self) -> Subscription<Message> {
  type Message (line 23) | enum Message {
  method default (line 135) | fn default() -> Self {
  function control (line 140) | fn control<'a>(

FILE: examples/custom_shader/src/scene.rs
  constant MAX (line 20) | pub const MAX: u32 = 500;
  type Scene (line 23) | pub struct Scene {
    method new (line 32) | pub fn new() -> Self {
    method update (line 46) | pub fn update(&mut self, time: Duration) {
    method change_amount (line 52) | pub fn change_amount(&mut self, amount: u32) {
    type State (line 82) | type State = ();
    type Primitive (line 83) | type Primitive = Primitive;
    method draw (line 85) | fn draw(
  type Primitive (line 103) | pub struct Primitive {
    method new (line 110) | pub fn new(
    type Pipeline (line 131) | type Pipeline = Pipeline;
    method prepare (line 133) | fn prepare(
    method render (line 152) | fn render(
  function rnd_origin (line 170) | fn rnd_origin() -> Vec3 {
  method new (line 179) | fn new(device: &wgpu::Device, queue: &wgpu::Queue, format: wgpu::Texture...

FILE: examples/custom_shader/src/scene/camera.rs
  type Camera (line 5) | pub struct Camera {
    method build_view_proj_matrix (line 35) | pub fn build_view_proj_matrix(&self, bounds: Rectangle) -> glam::Mat4 {
    method position (line 43) | pub fn position(&self) -> glam::Vec4 {
  method default (line 15) | fn default() -> Self {
  constant OPENGL_TO_WGPU_MATRIX (line 27) | pub const OPENGL_TO_WGPU_MATRIX: glam::Mat4 = mat4(

FILE: examples/custom_shader/src/scene/pipeline.rs
  constant SKY_TEXTURE_SIZE (line 17) | const SKY_TEXTURE_SIZE: u32 = 128;
  type Pipeline (line 19) | pub struct Pipeline {
    method new (line 31) | pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, format: wgpu::T...
    method update_depth_texture (line 282) | fn update_depth_texture(&mut self, device: &wgpu::Device, size: Size<u...
    method update (line 309) | pub fn update(
    method render (line 332) | pub fn render(
  type DepthPipeline (line 386) | struct DepthPipeline {
    method new (line 395) | pub fn new(
    method update (line 496) | pub fn update(&mut self, device: &wgpu::Device, depth_texture: &wgpu::...
    method render (line 515) | pub fn render(
  function load_skybox_data (line 556) | fn load_skybox_data() -> Vec<u8> {
  function load_normal_map_data (line 577) | fn load_normal_map_data() -> Vec<u8> {

FILE: examples/custom_shader/src/scene/pipeline/buffer.rs
  type Buffer (line 4) | pub struct Buffer {
    method new (line 12) | pub fn new(
    method resize (line 31) | pub fn resize(&mut self, device: &wgpu::Device, new_size: u64) {

FILE: examples/custom_shader/src/scene/pipeline/cube.rs
  type Cube (line 9) | pub struct Cube {
    method new (line 30) | pub fn new(size: f32, origin: Vec3) -> Self {
    method update (line 48) | pub fn update(&mut self, size: f32, time: f32) {
  method default (line 18) | fn default() -> Self {
  type Raw (line 57) | pub struct Raw {
    constant ATTRIBS (line 64) | const ATTRIBS: [wgpu::VertexAttribute; 7] = wgpu::vertex_attr_array![
    method desc (line 76) | pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {
    method from_cube (line 86) | pub fn from_cube(cube: &Cube) -> Raw {
    method vertices (line 98) | pub fn vertices() -> [Vertex; 36] {

FILE: examples/custom_shader/src/scene/pipeline/uniforms.rs
  type Uniforms (line 7) | pub struct Uniforms {
    method new (line 14) | pub fn new(camera: &Camera, bounds: Rectangle, light_color: Color) -> ...

FILE: examples/custom_shader/src/scene/pipeline/vertex.rs
  type Vertex (line 5) | pub struct Vertex {
    constant ATTRIBS (line 13) | const ATTRIBS: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![
    method desc (line 24) | pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {

FILE: examples/custom_widget/src/main.rs
  type Circle (line 10) | pub struct Circle {
    method new (line 15) | pub fn new(radius: f32) -> Self {
    method size (line 28) | fn size(&self) -> Size<Length> {
    method layout (line 35) | fn layout(
    method draw (line 44) | fn draw(
  function circle (line 20) | pub fn circle(radius: f32) -> Circle {
  function from (line 69) | fn from(circle: Circle) -> Self {
  function main (line 79) | pub fn main() -> iced::Result {
  type Example (line 83) | struct Example {
    method new (line 93) | fn new() -> Self {
    method update (line 97) | fn update(&mut self, message: Message) {
    method view (line 105) | fn view(&self) -> Element<'_, Message> {
  type Message (line 88) | enum Message {
  method default (line 121) | fn default() -> Self {

FILE: examples/delineate/src/main.rs
  function main (line 7) | pub fn main() -> iced::Result {
  type Example (line 15) | struct Example {
    method update (line 31) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 55) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 138) | fn subscription(&self) -> Subscription<Message> {
  type Message (line 22) | enum Message {
  constant OUTER_CONTAINER (line 149) | const OUTER_CONTAINER: widget::Id = widget::Id::new("outer");
  constant INNER_CONTAINER (line 150) | const INNER_CONTAINER: widget::Id = widget::Id::new("inner");

FILE: examples/download_progress/src/download.rs
  function download (line 6) | pub fn download(url: impl AsRef<str>) -> impl Straw<(), Progress, Error> {
  type Progress (line 32) | pub struct Progress {
  type Error (line 37) | pub enum Error {
    method from (line 43) | fn from(error: reqwest::Error) -> Self {

FILE: examples/download_progress/src/main.rs
  function main (line 9) | pub fn main() -> iced::Result {
  type Example (line 14) | struct Example {
    method new (line 27) | fn new() -> Self {
    method update (line 34) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 63) | fn view(&self) -> Element<'_, Message> {
  type Message (line 20) | pub enum Message {
  method default (line 78) | fn default() -> Self {
  type Download (line 84) | struct Download {
    method new (line 104) | pub fn new(id: usize) -> Self {
    method start (line 111) | pub fn start(&mut self) -> Task<Update> {
    method update (line 136) | pub fn update(&mut self, update: Update) {
    method view (line 153) | pub fn view(&self) -> Element<'_, Message> {
  type Update (line 90) | pub enum Update {
  type State (line 96) | enum State {

FILE: examples/editor/src/main.rs
  function main (line 15) | pub fn main() -> iced::Result {
  type Editor (line 23) | struct Editor {
    method new (line 45) | fn new() -> (Self, Task<Message>) {
    method update (line 65) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 145) | fn view(&self) -> Element<'_, Message> {
    method theme (line 233) | fn theme(&self) -> Theme {
  type Message (line 33) | enum Message {
  type Error (line 243) | pub enum Error {
  function open_file (line 248) | fn open_file(
  function load_file (line 262) | async fn load_file(path: impl Into<PathBuf>) -> Result<(PathBuf, Arc<Str...
  function save_file (line 273) | async fn save_file(path: Option<PathBuf>, contents: String) -> Result<Pa...
  function action (line 293) | fn action<'a, Message: Clone + 'a>(
  function new_icon (line 313) | fn new_icon<'a, Message>() -> Element<'a, Message> {
  function save_icon (line 317) | fn save_icon<'a, Message>() -> Element<'a, Message> {
  function open_icon (line 321) | fn open_icon<'a, Message>() -> Element<'a, Message> {
  function icon (line 325) | fn icon<'a, Message>(codepoint: char) -> Element<'a, Message> {
  constant EDITOR (line 334) | const EDITOR: &str = "editor";

FILE: examples/events/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Events (line 14) | struct Events {
    method update (line 27) | fn update(&mut self, message: Message) -> Task<Message> {
    method subscription (line 54) | fn subscription(&self) -> Subscription<Message> {
    method view (line 58) | fn view(&self) -> Element<'_, Message> {
  type Message (line 20) | enum Message {

FILE: examples/exit/src/main.rs
  function main (line 5) | pub fn main() -> iced::Result {
  type Exit (line 10) | struct Exit {
    method update (line 21) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 32) | fn view(&self) -> Element<'_, Message> {
  type Message (line 15) | enum Message {

FILE: examples/ferris/src/main.rs
  function main (line 9) | pub fn main() -> iced::Result {
  type Image (line 16) | struct Image {
    method update (line 37) | fn update(&mut self, message: Message) {
    method subscription (line 77) | fn subscription(&self) -> Subscription<Message> {
    method view (line 85) | fn view(&self) -> Element<'_, Message> {
  type Message (line 26) | enum Message {
  method default (line 169) | fn default() -> Self {
  type RotationStrategy (line 182) | enum RotationStrategy {
    method fmt (line 188) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function with_value (line 196) | fn with_value<'a>(control: impl Into<Element<'a, Message>>, value: Strin...

FILE: examples/gallery/src/civitai.rs
  type Image (line 12) | pub struct Image {
    constant LIMIT (line 19) | pub const LIMIT: usize = 200;
    method list (line 21) | pub async fn list() -> Result<Vec<Self>, Error> {
    method blurhash (line 48) | pub async fn blurhash(self, width: u32, height: u32) -> Result<Blurhas...
    method download (line 63) | pub fn download(self, size: Size) -> impl Straw<Bytes, Blurhash, Error> {
  type Id (line 103) | pub struct Id(u32);
  type Blurhash (line 106) | pub struct Blurhash {
  type Rgba (line 111) | pub struct Rgba {
    method fmt (line 118) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Bytes (line 127) | pub struct Bytes(bytes::Bytes);
    method as_slice (line 130) | pub fn as_slice(&self) -> &[u8] {
    method fmt (line 142) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 136) | fn from(value: Bytes) -> Self {
  type Size (line 150) | pub enum Size {
  type Error (line 157) | pub enum Error {
    method from (line 166) | fn from(error: reqwest::Error) -> Self {
    method from (line 172) | fn from(error: io::Error) -> Self {
    method from (line 178) | fn from(error: task::JoinError) -> Self {
    method from (line 184) | fn from(error: blurhash::Error) -> Self {

FILE: examples/gallery/src/main.rs
  function main (line 22) | fn main() -> iced::Result {
  type Gallery (line 34) | struct Gallery {
    method new (line 59) | pub fn new() -> (Self, Task<Message>) {
    method theme (line 73) | pub fn theme(&self) -> Theme {
    method subscription (line 77) | pub fn subscription(&self) -> Subscription<Message> {
    method update (line 91) | pub fn update(&mut self, message: Message, now: Instant) -> Task<Messa...
    method view (line 245) | pub fn view(&self) -> Element<'_, Message> {
  type Message (line 44) | enum Message {
  function card (line 281) | fn card<'a>(
  function placeholder (line 352) | fn placeholder<'a>() -> Element<'a, Message> {
  type Preview (line 356) | enum Preview {
    constant WIDTH (line 391) | const WIDTH: u32 = 320;
    constant HEIGHT (line 392) | const HEIGHT: u32 = 410;
    method loading (line 394) | fn loading(rgba: Rgba, now: Instant) -> Self {
    method ready (line 406) | fn ready(bytes: Bytes) -> Self {
    method load (line 413) | fn load(self, bytes: Bytes) -> Self {
    method toggle_zoom (line 424) | fn toggle_zoom(&mut self, enabled: bool, now: Instant) {
    method is_animating (line 430) | fn is_animating(&self, now: Instant) -> bool {
    method blurhash (line 446) | fn blurhash(&self, now: Instant) -> Option<&Blurhash> {
  type Blurhash (line 366) | struct Blurhash {
    method show (line 372) | pub fn show(&mut self, now: Instant) {
    method reset (line 376) | pub fn reset(&mut self) {
  type Thumbnail (line 383) | struct Thumbnail {
    method new (line 462) | pub fn new(bytes: Bytes) -> Self {
    method reset (line 475) | pub fn reset(&mut self) {
    method show (line 482) | pub fn show(&mut self, allocation: image::Allocation, now: Instant) {
  type Viewer (line 488) | struct Viewer {
    method new (line 495) | fn new() -> Self {
    method open (line 507) | fn open(&mut self, now: Instant) {
    method show (line 512) | fn show(&mut self, allocation: image::Allocation, now: Instant) {
    method close (line 518) | fn close(&mut self, now: Instant) {
    method is_animating (line 523) | fn is_animating(&self, now: Instant) -> bool {
    method view (line 527) | fn view(&self, now: Instant) -> Option<Element<'_, Message>> {
  function to_rgba (line 556) | fn to_rgba(bytes: Bytes) -> Task<image::Handle> {
  function rounded (line 571) | fn rounded(theme: &Theme) -> container::Style {
  constant BORDER_RADIUS (line 575) | const BORDER_RADIUS: u32 = 10;

FILE: examples/game_of_life/src/main.rs
  function main (line 12) | pub fn main() -> iced::Result {
  type GameOfLife (line 22) | struct GameOfLife {
    method new (line 44) | fn new() -> Self {
    method update (line 55) | fn update(&mut self, message: Message) -> Task<Message> {
    method subscription (line 103) | fn subscription(&self) -> Subscription<Message> {
    method view (line 111) | fn view(&self) -> Element<'_, Message> {
  type Message (line 32) | enum Message {
  method default (line 129) | fn default() -> Self {
  function view_controls (line 134) | fn view_controls<'a>(
  type Grid (line 190) | pub struct Grid {
    constant MIN_SCALING (line 226) | const MIN_SCALING: f32 = 0.1;
    constant MAX_SCALING (line 227) | const MAX_SCALING: f32 = 2.0;
    method from_preset (line 229) | pub fn from_preset(preset: Preset) -> Self {
    method tick (line 249) | pub fn tick(&mut self, amount: usize) -> Option<impl Future<Output = M...
    method update (line 266) | pub fn update(&mut self, message: Message) {
    method view (line 313) | pub fn view(&self) -> Element<'_, Message> {
    method clear (line 317) | pub fn clear(&mut self) {
    method preset (line 324) | pub fn preset(&self) -> Preset {
    method toggle_lines (line 328) | pub fn toggle_lines(&mut self, enabled: bool) {
    method are_lines_visible (line 332) | pub fn are_lines_visible(&self) -> bool {
    method visible_region (line 336) | fn visible_region(&self, size: Size) -> Region {
    method project (line 348) | fn project(&self, position: Point, size: Size) -> Point {
    type State (line 359) | type State = Interaction;
    method update (line 361) | fn update(
    method draw (line 497) | fn draw(
    method mouse_interaction (line 626) | fn mouse_interaction(
  type Message (line 203) | pub enum Message {
  type TickError (line 215) | pub enum TickError {
  method default (line 220) | fn default() -> Self {
  type State (line 643) | struct State {
    method with_life (line 650) | pub fn with_life(life: Life) -> Self {
    method cell_count (line 657) | fn cell_count(&self) -> usize {
    method contains (line 661) | fn contains(&self, cell: &Cell) -> bool {
    method cells (line 665) | fn cells(&self) -> impl Iterator<Item = &Cell> {
    method populate (line 669) | fn populate(&mut self, cell: Cell) {
    method unpopulate (line 677) | fn unpopulate(&mut self, cell: &Cell) {
    method update (line 685) | fn update(&mut self, mut life: Life) {
    method tick (line 692) | fn tick(
  type Life (line 719) | pub struct Life {
    method len (line 724) | fn len(&self) -> usize {
    method contains (line 728) | fn contains(&self, cell: &Cell) -> bool {
    method populate (line 732) | fn populate(&mut self, cell: Cell) {
    method unpopulate (line 736) | fn unpopulate(&mut self, cell: &Cell) {
    method tick (line 740) | fn tick(&mut self) {
    method iter (line 766) | pub fn iter(&self) -> impl Iterator<Item = &Cell> {
    method from_iter (line 772) | fn from_iter<I: IntoIterator<Item = Cell>>(iter: I) -> Self {
    method fmt (line 780) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Cell (line 788) | pub struct Cell {
    constant SIZE (line 794) | const SIZE: u16 = 20;
    method at (line 796) | fn at(position: Point) -> Cell {
    method cluster (line 806) | fn cluster(cell: Cell) -> impl Iterator<Item = Cell> {
    method neighbors (line 815) | fn neighbors(cell: Cell) -> impl Iterator<Item = Cell> {
  type Region (line 820) | pub struct Region {
    method rows (line 828) | fn rows(&self) -> RangeInclusive<isize> {
    method columns (line 836) | fn columns(&self) -> RangeInclusive<isize> {
    method cull (line 844) | fn cull<'a>(
  type Interaction (line 856) | pub enum Interaction {

FILE: examples/game_of_life/src/preset.rs
  type Preset (line 2) | pub enum Preset {
    method life (line 30) | pub fn life(self) -> Vec<(isize, isize)> {
    method fmt (line 117) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: examples/geometry/src/main.rs
  type Rainbow (line 13) | pub struct Rainbow;
    method size (line 20) | fn size(&self) -> Size<Length> {
    method layout (line 27) | fn layout(
    method update (line 38) | fn update(
    method draw (line 53) | fn draw(
  function rainbow (line 15) | pub fn rainbow() -> Rainbow {
  function from (line 157) | fn from(rainbow: Rainbow) -> Self {
  function main (line 167) | pub fn main() -> iced::Result {
  function view (line 171) | fn view(_state: &()) -> Element<'_, Never> {

FILE: examples/gradient/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Gradient (line 16) | struct Gradient {
    method new (line 32) | fn new() -> Self {
    method update (line 41) | fn update(&mut self, message: Message) {
    method view (line 52) | fn view(&self) -> Element<'_, Message> {
    method style (line 96) | fn style(&self, theme: &Theme) -> theme::Style {
  type Message (line 24) | enum Message {
  method default (line 109) | fn default() -> Self {
  function color_picker (line 114) | fn color_picker(label: &str, color: Color) -> Element<'_, Color> {

FILE: examples/integration/src/controls.rs
  type Controls (line 5) | pub struct Controls {
    method new (line 17) | pub fn new() -> Controls {
    method background_color (line 24) | pub fn background_color(&self) -> Color {
    method update (line 30) | pub fn update(&mut self, message: Message) {
    method view (line 41) | pub fn view(&self) -> Element<'_, Message, Theme, Renderer> {
  type Message (line 11) | pub enum Message {

FILE: examples/integration/src/main.rs
  function main (line 27) | pub fn main() -> Result<(), winit::error::EventLoopError> {

FILE: examples/integration/src/scene.rs
  type Scene (line 4) | pub struct Scene {
    method new (line 9) | pub fn new(device: &wgpu::Device, texture_format: wgpu::TextureFormat)...
    method clear (line 15) | pub fn clear<'a>(
    method draw (line 47) | pub fn draw<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
  function build_pipeline (line 53) | fn build_pipeline(

FILE: examples/layout/src/main.rs
  function main (line 13) | pub fn main() -> iced::Result {
  type Layout (line 22) | struct Layout {
    method title (line 37) | fn title(&self) -> String {
    method update (line 41) | fn update(&mut self, message: Message) {
    method subscription (line 58) | fn subscription(&self) -> Subscription<Message> {
    method view (line 79) | fn view(&self) -> Element<'_, Message> {
    method theme (line 126) | fn theme(&self) -> Option<Theme> {
  type Message (line 29) | enum Message {
  type Example (line 132) | struct Example {
    constant LIST (line 138) | const LIST: &'static [Self] = &[
    method is_first (line 173) | fn is_first(self) -> bool {
    method is_last (line 177) | fn is_last(self) -> bool {
    method previous (line 181) | fn previous(self) -> Self {
    method next (line 192) | fn next(self) -> Self {
    method view (line 200) | fn view(&self) -> Element<'_, Message> {
  method default (line 206) | fn default() -> Self {
  method eq (line 212) | fn eq(&self, other: &Self) -> bool {
  function centered (line 217) | fn centered<'a>() -> Element<'a, Message> {
  function column_ (line 221) | fn column_<'a>() -> Element<'a, Message> {
  function row_ (line 235) | fn row_<'a>() -> Element<'a, Message> {
  function space_ (line 247) | fn space_<'a>() -> Element<'a, Message> {
  function application (line 251) | fn application<'a>() -> Element<'a, Message> {
  function quotes (line 299) | fn quotes<'a>() -> Element<'a, Message> {
  function pinning (line 327) | fn pinning<'a>() -> Element<'a, Message> {
  function responsive_ (line 344) | fn responsive_<'a>() -> Element<'a, Message> {
  function square (line 379) | fn square<'a>(size: impl Into<Length> + Copy) -> Element<'a, Message> {

FILE: examples/lazy/src/main.rs
  function main (line 7) | pub fn main() -> iced::Result {
  type App (line 11) | struct App {
    method update (line 121) | fn update(&mut self, message: Message) {
    method view (line 154) | fn view(&self) -> Element<'_, Message> {
  method default (line 19) | fn default() -> Self {
  type Color (line 33) | enum Color {
    constant ALL (line 45) | const ALL: &'static [Color] = &[
    method fmt (line 57) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 71) | fn from(value: Color) -> Self {
  type Item (line 85) | struct Item {
    method from (line 103) | fn from(s: &str) -> Self {
  method hash (line 91) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method eq (line 97) | fn eq(&self, other: &Self) -> bool {
  type Message (line 112) | enum Message {
  type Order (line 198) | enum Order {
    method fmt (line 204) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: examples/loading_spinners/src/circular.rs
  constant MIN_ANGLE (line 17) | const MIN_ANGLE: Radians = Radians(PI / 8.0);
  constant WRAP_ANGLE (line 18) | const WRAP_ANGLE: Radians = Radians(2.0 * PI - PI / 4.0);
  constant BASE_ROTATION_SPEED (line 19) | const BASE_ROTATION_SPEED: u32 = u32::MAX / 80;
  type Circular (line 21) | pub struct Circular<'a, Theme>
  function new (line 38) | pub fn new() -> Self {
  function size (line 50) | pub fn size(mut self, size: f32) -> Self {
  function bar_height (line 56) | pub fn bar_height(mut self, bar_height: f32) -> Self {
  function style (line 62) | pub fn style(mut self, style: <Theme as StyleSheet>::Style) -> Self {
  function easing (line 68) | pub fn easing(mut self, easing: &'a Easing) -> Self {
  function cycle_duration (line 74) | pub fn cycle_duration(mut self, duration: Duration) -> Self {
  function rotation_duration (line 81) | pub fn rotation_duration(mut self, duration: Duration) -> Self {
  method default (line 91) | fn default() -> Self {
  type Animation (line 97) | enum Animation {
    method next (line 124) | fn next(&self, additional_rotation: u32, now: Instant) -> Self {
    method start (line 143) | fn start(&self) -> Instant {
    method last (line 149) | fn last(&self) -> Instant {
    method timed_transition (line 155) | fn timed_transition(
    method with_elapsed (line 172) | fn with_elapsed(
    method rotation (line 200) | fn rotation(&self) -> f32 {
  method default (line 113) | fn default() -> Self {
  type State (line 210) | struct State {
  function tag (line 220) | fn tag(&self) -> tree::Tag {
  function state (line 224) | fn state(&self) -> tree::State {
  function size (line 228) | fn size(&self) -> Size<Length> {
  function layout (line 235) | fn layout(
  function update (line 244) | fn update(
  function draw (line 267) | fn draw(
  function from (line 340) | fn from(circular: Circular<'a, Theme>) -> Self {
  type Appearance (line 346) | pub struct Appearance {
    method default (line 356) | fn default() -> Self {
  type StyleSheet (line 366) | pub trait StyleSheet {
    method appearance (line 371) | fn appearance(&self, style: &Self::Style) -> Appearance;
    type Style (line 375) | type Style = ();
    method appearance (line 377) | fn appearance(&self, _style: &Self::Style) -> Appearance {

FILE: examples/loading_spinners/src/easing.rs
  type Easing (line 45) | pub struct Easing {
    method builder (line 51) | pub fn builder() -> Builder {
    method y_at_x (line 55) | pub fn y_at_x(&self, x: f32) -> f32 {
  type Builder (line 65) | pub struct Builder(NoAttributes<BuilderImpl>);
    method new (line 68) | pub fn new() -> Self {
    method line_to (line 76) | pub fn line_to(mut self, to: impl Into<Point>) -> Self {
    method quadratic_bezier_to (line 83) | pub fn quadratic_bezier_to(mut self, ctrl: impl Into<Point>, to: impl ...
    method cubic_bezier_to (line 91) | pub fn cubic_bezier_to(
    method build (line 103) | pub fn build(mut self) -> Easing {
    method point (line 113) | fn point(p: impl Into<Point>) -> lyon_algorithms::geom::Point<f32> {
  method default (line 120) | fn default() -> Self {

FILE: examples/loading_spinners/src/linear.rs
  type Linear (line 15) | pub struct Linear<'a, Theme>
  function new (line 31) | pub fn new() -> Self {
  function width (line 42) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 48) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function style (line 54) | pub fn style(mut self, style: impl Into<Theme::Style>) -> Self {
  function easing (line 60) | pub fn easing(mut self, easing: &'a Easing) -> Self {
  function cycle_duration (line 66) | pub fn cycle_duration(mut self, duration: Duration) -> Self {
  method default (line 76) | fn default() -> Self {
  type State (line 82) | enum State {
    method next (line 97) | fn next(&self, now: Instant) -> Self {
    method start (line 110) | fn start(&self) -> Instant {
    method timed_transition (line 116) | fn timed_transition(&self, cycle_duration: Duration, now: Instant) -> ...
    method with_elapsed (line 125) | fn with_elapsed(&self, cycle_duration: Duration, elapsed: Duration) ->...
  method default (line 88) | fn default() -> Self {
  function tag (line 146) | fn tag(&self) -> tree::Tag {
  function state (line 150) | fn state(&self) -> tree::State {
  function size (line 154) | fn size(&self) -> Size<Length> {
  function layout (line 161) | fn layout(
  function update (line 170) | fn update(
  function draw (line 189) | fn draw(
  function from (line 252) | fn from(linear: Linear<'a, Theme>) -> Self {
  type Appearance (line 258) | pub struct Appearance {
  method default (line 266) | fn default() -> Self {
  type StyleSheet (line 275) | pub trait StyleSheet {
    method appearance (line 280) | fn appearance(&self, style: &Self::Style) -> Appearance;
    type Style (line 284) | type Style = ();
    method appearance (line 286) | fn appearance(&self, _style: &Self::Style) -> Appearance {

FILE: examples/loading_spinners/src/main.rs
  function main (line 13) | pub fn main() -> iced::Result {
  type LoadingSpinners (line 22) | struct LoadingSpinners {
    method update (line 32) | fn update(&mut self, message: Message) {
    method view (line 40) | fn view(&self) -> Element<'_, Message> {
  type Message (line 27) | enum Message {
  method default (line 94) | fn default() -> Self {

FILE: examples/loupe/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Loupe (line 11) | struct Loupe {
    method update (line 22) | fn update(&mut self, message: Message) {
    method view (line 33) | fn view(&self) -> Element<'_, Message> {
  type Message (line 16) | enum Message {
  function loupe (line 56) | pub fn loupe<'a, Message>(
  type Loupe (line 69) | pub struct Loupe<'a, Message> {
    method update (line 22) | fn update(&mut self, message: Message) {
    method view (line 33) | fn view(&self) -> Element<'_, Message> {
  function tag (line 75) | fn tag(&self) -> widget::tree::Tag {
  function state (line 79) | fn state(&self) -> widget::tree::State {
  function children (line 83) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 87) | fn diff(&self, tree: &mut widget::Tree) {
  function size (line 91) | fn size(&self) -> Size<Length> {
  function layout (line 95) | fn layout(
  function draw (line 104) | fn draw(
  function mouse_interaction (line 144) | fn mouse_interaction(
  function from (line 164) | fn from(loupe: Loupe<'a, Message>) -> Self {

FILE: examples/markdown/build.rs
  function main (line 1) | pub fn main() {

FILE: examples/markdown/src/icon.rs
  constant FONT (line 6) | pub const FONT: &[u8] = include_bytes!("../fonts/markdown-icons.ttf");
  function copy (line 8) | pub fn copy<'a>() -> Text<'a> {
  function icon (line 12) | fn icon(codepoint: &str) -> Text<'_> {

FILE: examples/markdown/src/main.rs
  function main (line 18) | pub fn main() -> iced::Result {
  type Markdown (line 30) | struct Markdown {
    method new (line 67) | fn new() -> (Self, Task<Message>) {
    method update (line 83) | fn update(&mut self, message: Message, now: Instant) -> Task<Message> {
    method view (line 171) | fn view(&self) -> Element<'_, Message> {
    method theme (line 210) | fn theme(&self) -> Theme {
    method subscription (line 214) | fn subscription(&self) -> Subscription<Message> {
  type Mode (line 39) | enum Mode {
  type Image (line 44) | enum Image {
  type Message (line 55) | enum Message {
  type CustomViewer (line 237) | struct CustomViewer<'a> {
  function on_link_click (line 243) | fn on_link_click(url: markdown::Uri) -> Message {
  function image (line 247) | fn image(
  function code_block (line 270) | fn code_block(
  function download_image (line 291) | async fn download_image(uri: markdown::Uri) -> Result<image::Handle, Err...
  type Error (line 335) | pub enum Error {
    method from (line 343) | fn from(error: reqwest::Error) -> Self {
    method from (line 349) | fn from(error: io::Error) -> Self {
    method from (line 355) | fn from(error: tokio::task::JoinError) -> Self {
    method from (line 361) | fn from(error: ::image::ImageError) -> Self {

FILE: examples/modal/src/main.rs
  function main (line 12) | pub fn main() -> iced::Result {
  type App (line 19) | struct App {
    method subscription (line 38) | fn subscription(&self) -> Subscription<Message> {
    method update (line 42) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 95) | fn view(&self) -> Element<'_, Message> {
    method hide_modal (line 159) | fn hide_modal(&mut self) {
  type Message (line 27) | enum Message {
  type Plan (line 167) | enum Plan {
    constant ALL (line 175) | pub const ALL: &'static [Self] = &[Self::Basic, Self::Pro, Self::Enter...
    method fmt (line 179) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function modal (line 189) | fn modal<'a, Message>(

FILE: examples/multi_window/src/main.rs
  function main (line 9) | fn main() -> iced::Result {
  type Example (line 18) | struct Example {
    method new (line 41) | fn new() -> (Self, Task<Message>) {
    method title (line 52) | fn title(&self, window: window::Id) -> String {
    method update (line 59) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 126) | fn view(&self, window_id: window::Id) -> Element<'_, Message> {
    method theme (line 134) | fn theme(&self, window: window::Id) -> Option<Theme> {
    method scale_factor (line 138) | fn scale_factor(&self, window: window::Id) -> f32 {
    method subscription (line 145) | fn subscription(&self) -> Subscription<Message> {
  type Window (line 23) | struct Window {
    method new (line 151) | fn new(count: usize) -> Self {
    method view (line 160) | fn view(&self, id: window::Id) -> Element<'_, Message> {
  type Message (line 31) | enum Message {

FILE: examples/multitouch/src/main.rs
  function main (line 12) | pub fn main() -> iced::Result {
  type Multitouch (line 21) | struct Multitouch {
    method update (line 33) | fn update(&mut self, message: Message) {
    method view (line 46) | fn view(&self) -> Element<'_, Message> {
    type State (line 52) | type State = ();
    method update (line 54) | fn update(
    method draw (line 77) | fn draw(
  type Message (line 27) | enum Message {

FILE: examples/pane_grid/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Example (line 12) | struct Example {
    method new (line 34) | fn new() -> Self {
    method update (line 44) | fn update(&mut self, message: Message) {
    method subscription (line 109) | fn subscription(&self) -> Subscription<Message> {
    method view (line 123) | fn view(&self) -> Element<'_, Message> {
  type Message (line 19) | enum Message {
  method default (line 186) | fn default() -> Self {
  constant PANE_ID_COLOR_UNFOCUSED (line 191) | const PANE_ID_COLOR_UNFOCUSED: Color = Color::from_rgb(
  constant PANE_ID_COLOR_FOCUSED (line 196) | const PANE_ID_COLOR_FOCUSED: Color = Color::from_rgb(
  function handle_hotkey (line 202) | fn handle_hotkey(key: keyboard::Key) -> Option<Message> {
  type Pane (line 226) | struct Pane {
    method new (line 232) | fn new(id: usize) -> Self {
  function view_content (line 240) | fn view_content<'a>(
  function view_controls (line 278) | fn view_controls<'a>(
  function title_bar_active (line 317) | pub fn title_bar_active(theme: &Theme) -> container::Style {
  function title_bar_focused (line 327) | pub fn title_bar_focused(theme: &Theme) -> container::Style {
  function pane_active (line 337) | pub fn pane_active(theme: &Theme) -> container::Style {
  function pane_focused (line 351) | pub fn pane_focused(theme: &Theme) -> container::Style {

FILE: examples/pick_list/src/main.rs
  function main (line 4) | pub fn main() -> iced::Result {
  type Example (line 9) | struct Example {
    method update (line 19) | fn update(&mut self, message: Message) {
    method view (line 27) | fn view(&self) -> Element<'_, Message> {
  type Message (line 14) | enum Message {
  type Language (line 47) | pub enum Language {
    constant ALL (line 59) | const ALL: &[Language] = &[
    method fmt (line 71) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: examples/pokedex/src/main.rs
  function main (line 5) | pub fn main() -> iced::Result {
  type Pokedex (line 12) | enum Pokedex {
    method new (line 25) | fn new() -> (Self, Task<Message>) {
    method search (line 29) | fn search() -> Task<Message> {
    method title (line 33) | fn title(&self) -> String {
    method update (line 43) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 66) | fn view(&self) -> Element<'_, Message> {
  type Message (line 19) | enum Message {
  type Pokemon (line 91) | struct Pokemon {
    constant TOTAL (line 99) | const TOTAL: u16 = 807;
    method view (line 101) | fn view(&self) -> Element<'_, Message> {
    method search (line 120) | async fn search() -> Result<Pokemon, Error> {
    method fetch_image (line 174) | async fn fetch_image(id: u16) -> Result<image::Handle, reqwest::Error> {
  type Error (line 192) | enum Error {
    method from (line 198) | fn from(error: reqwest::Error) -> Error {
  function button (line 205) | fn button(text: &str) -> widget::Button<'_, Message> {

FILE: examples/progress_bar/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Progress (line 11) | struct Progress {
    method update (line 23) | fn update(&mut self, message: Message) {
    method view (line 30) | fn view(&self) -> Element<'_, Message> {
  type Message (line 17) | enum Message {

FILE: examples/qr_code/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type QRGenerator (line 13) | struct QRGenerator {
    constant SIZE_RANGE (line 29) | const SIZE_RANGE: RangeInclusive<f32> = 200.0..=400.0;
    method update (line 31) | fn update(&mut self, message: Message) {
    method view (line 59) | fn view(&self) -> Element<'_, Message> {
    method theme (line 104) | fn theme(&self) -> Option<Theme> {
  type Message (line 21) | enum Message {

FILE: examples/sandpiles/src/main.rs
  function main (line 11) | pub fn main() -> iced::Result {
  type Sandpiles (line 17) | struct Sandpiles {
    method new (line 32) | fn new() -> Self {
    method update (line 50) | fn update(&mut self, message: Message) {
    method view (line 73) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 101) | fn subscription(&self) -> Subscription<Message> {
  type Message (line 25) | enum Message {
  type Grid (line 111) | struct Grid {
    method new (line 117) | pub fn new() -> Self {
    method add (line 124) | pub fn add(&mut self, cell: Cell, amount: u32) {
    method topple (line 134) | pub fn topple(&mut self) -> bool {
  type Cell (line 154) | struct Cell {
    constant ORIGIN (line 160) | pub const ORIGIN: Self = Self { row: 0, column: 0 };
    method neighbors (line 162) | pub fn neighbors(self) -> impl Iterator<Item = Cell> {
  type Viewer (line 172) | struct Viewer<'a> {
  constant CELL_SIZE (line 178) | const CELL_SIZE: f32 = 10.0;
  type State (line 182) | type State = ();
  function update (line 184) | fn update(
  function draw (line 206) | fn draw(
  function mouse_interaction (line 283) | fn mouse_interaction(

FILE: examples/screenshot/src/main.rs
  function main (line 10) | fn main() -> iced::Result {
  type Example (line 19) | struct Example {
    method update (line 44) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 116) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 214) | fn subscription(&self) -> Subscription<Message> {
  type Message (line 31) | enum Message {
  function save_to_png (line 231) | async fn save_to_png(screenshot: Screenshot) -> Result<String, PngError> {
  type PngError (line 250) | struct PngError(String);
  function numeric_input (line 252) | fn numeric_input(placeholder: &str, value: Option<u32>) -> Element<'_, O...
  function centered_text (line 270) | fn centered_text(content: &str) -> Element<'_, Message> {

FILE: examples/scrollable/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type ScrollableDemo (line 16) | struct ScrollableDemo {
    method new (line 45) | fn new() -> Self {
    method update (line 56) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 103) | fn view(&self) -> Element<'_, Message> {
    method theme (line 306) | fn theme(&self) -> Theme {
  type Direction (line 26) | enum Direction {
  type Message (line 33) | enum Message {
  method default (line 312) | fn default() -> Self {
  function progress_bar_custom_style (line 317) | fn progress_bar_custom_style(theme: &Theme) -> progress_bar::Style {
  constant SCROLLABLE (line 325) | const SCROLLABLE: &str = "scrollable";

FILE: examples/sierpinski_triangle/src/main.rs
  function main (line 9) | fn main() -> iced::Result {
  type SierpinskiEmulator (line 19) | struct SierpinskiEmulator {
    method update (line 31) | fn update(&mut self, message: Message) {
    method view (line 49) | fn view(&self) -> Element<'_, Message> {
  type Message (line 24) | pub enum Message {
  type SierpinskiGraph (line 65) | struct SierpinskiGraph {
    type State (line 73) | type State = ();
    method update (line 75) | fn update(
    method draw (line 97) | fn draw(
    method redraw (line 137) | fn redraw(&mut self) {
    method gen_rand_point (line 141) | fn gen_rand_point(&self, last: Option<Point>) -> Point {

FILE: examples/slider/src/main.rs
  function main (line 4) | pub fn main() -> iced::Result {
  type Message (line 9) | pub enum Message {
  type Slider (line 13) | pub struct Slider {
    method new (line 18) | fn new() -> Self {
    method update (line 22) | fn update(&mut self, message: Message) {
    method view (line 30) | fn view(&self) -> Element<'_, Message> {
  method default (line 57) | fn default() -> Self {

FILE: examples/solar_system/src/main.rs
  function main (line 18) | pub fn main() -> iced::Result {
  type SolarSystem (line 31) | struct SolarSystem {
    method new (line 41) | fn new() -> Self {
    method update (line 47) | fn update(&mut self, message: Message, now: Instant) {
    method view (line 55) | fn view(&self) -> Element<'_, Message> {
    method theme (line 59) | fn theme(&self) -> Theme {
    method subscription (line 63) | fn subscription(&self) -> Subscription<Message> {
  type Message (line 36) | enum Message {
  type State (line 69) | struct State {
    constant SUN_RADIUS (line 81) | const SUN_RADIUS: f32 = 70.0;
    constant ORBIT_RADIUS (line 82) | const ORBIT_RADIUS: f32 = 150.0;
    constant EARTH_RADIUS (line 83) | const EARTH_RADIUS: f32 = 12.0;
    constant MOON_RADIUS (line 84) | const MOON_RADIUS: f32 = 4.0;
    constant MOON_DISTANCE (line 85) | const MOON_DISTANCE: f32 = 28.0;
    method new (line 87) | pub fn new() -> State {
    method update (line 103) | pub fn update(&mut self, now: Instant) {
    method generate_stars (line 109) | fn generate_stars(width: f32, height: f32) -> Vec<(Point, f32)> {
    type State (line 129) | type State = ();
    method draw (line 131) | fn draw(

FILE: examples/stopwatch/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type Stopwatch (line 13) | struct Stopwatch {
    method update (line 35) | fn update(&mut self, message: Message) {
    method subscription (line 59) | fn subscription(&self) -> Subscription<Message> {
    method view (line 82) | fn view(&self) -> Element<'_, Message> {
  type State (line 19) | enum State {
  type Message (line 28) | enum Message {

FILE: examples/styling/src/main.rs
  function main (line 8) | pub fn main() -> iced::Result {
  type Styling (line 16) | struct Styling {
    method update (line 38) | fn update(&mut self, message: Message) {
    method view (line 75) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 171) | fn subscription(&self) -> Subscription<Message> {
    method theme (line 195) | fn theme(&self) -> Option<Theme> {
  type Message (line 25) | enum Message {
  function it_showcases_every_theme (line 209) | fn it_showcases_every_theme() -> Result<(), Error> {

FILE: examples/svg/src/main.rs
  function main (line 4) | pub fn main() -> iced::Result {
  type Tiger (line 9) | struct Tiger {
    method update (line 19) | fn update(&mut self, message: Message) {
    method view (line 27) | fn view(&self) -> Element<'_, Message> {
  type Message (line 14) | pub enum Message {

FILE: examples/system_information/src/main.rs
  function main (line 5) | pub fn main() -> iced::Result {
  type Example (line 11) | enum Example {
    method new (line 27) | fn new() -> (Self, Task<Message>) {
    method update (line 34) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 51) | fn view(&self) -> Element<'_, Message> {
  type Message (line 21) | enum Message {

FILE: examples/table/src/main.rs
  function main (line 8) | pub fn main() -> iced::Result {
  type Table (line 14) | struct Table {
    method new (line 27) | fn new() -> Self {
    method update (line 35) | fn update(&mut self, message: Message) {
    method view (line 42) | fn view(&self) -> Element<'_, Message> {
  type Message (line 21) | enum Message {
  type Event (line 141) | struct Event {
    method list (line 149) | fn list() -> Vec<Self> {

FILE: examples/text/src/main.rs
  function main (line 7) | pub fn main() -> iced::Result {
  type Text (line 13) | struct Text {
    method new (line 27) | fn new() -> (Self, Task<Message>) {
    method update (line 46) | fn update(&mut self, message: Message) {
    method subscription (line 63) | fn subscription(&self) -> Subscription<Message> {
    method view (line 73) | fn view(&self) -> Element<'_, Message> {
  type Message (line 20) | enum Message {

FILE: examples/the_matrix/src/main.rs
  function main (line 8) | pub fn main() -> iced::Result {
  type TheMatrix (line 17) | struct TheMatrix {
    method update (line 27) | fn update(&mut self, message: Message) {
    method view (line 35) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 39) | fn subscription(&self) -> Subscription<Message> {
    type State (line 45) | type State = RefCell<Vec<canvas::Cache>>;
    method draw (line 47) | fn draw(
  type Message (line 22) | enum Message {

FILE: examples/toast/src/main.rs
  function main (line 9) | pub fn main() -> iced::Result {
  type App (line 15) | struct App {
    method new (line 34) | fn new() -> Self {
    method subscription (line 46) | fn subscription(&self) -> Subscription<Message> {
    method update (line 50) | fn update(&mut self, message: Message) -> Task<Message> {
    method view (line 91) | fn view(&self) -> Element<'_, Message> {
  type Message (line 23) | enum Message {
  method default (line 150) | fn default() -> Self {
  constant DEFAULT_TIMEOUT (line 172) | pub const DEFAULT_TIMEOUT: u64 = 5;
  type Status (line 175) | pub enum Status {
    constant ALL (line 185) | pub const ALL: &'static [Self] = &[
    method fmt (line 195) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Toast (line 208) | pub struct Toast {
  type Manager (line 214) | pub struct Manager<'a, Message> {
  function new (line 225) | pub fn new(
  function timeout (line 271) | pub fn timeout(self, seconds: u64) -> Self {
  function size (line 280) | fn size(&self) -> Size<Length> {
  function layout (line 284) | fn layout(
  function tag (line 295) | fn tag(&self) -> widget::tree::Tag {
  function state (line 300) | fn state(&self) -> widget::tree::State {
  function children (line 304) | fn children(&self) -> Vec<Tree> {
  function diff (line 310) | fn diff(&self, tree: &mut Tree) {
  function operate (line 335) | fn operate(
  function update (line 353) | fn update(
  function draw (line 374) | fn draw(
  function mouse_interaction (line 395) | fn mouse_interaction(
  function overlay (line 412) | fn overlay<'b>(
  type Overlay (line 449) | struct Overlay<'a, 'b, Message> {
  function layout (line 460) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function update (line 478) | fn update(
  function draw (line 535) | fn draw(
  function operate (line 557) | fn operate(
  function mouse_interaction (line 577) | fn mouse_interaction(
  function from (line 606) | fn from(manager: Manager<'a, Message>) -> Self {

FILE: examples/todos/src/main.rs
  function main (line 15) | pub fn main() -> iced::Result {
  function application (line 22) | fn application() -> Application<impl Program<Message = Message, Theme = ...
  type Todos (line 32) | enum Todos {
    constant ICON_FONT (line 59) | const ICON_FONT: &'static [u8] = include_bytes!("../fonts/icons.ttf");
    method new (line 61) | fn new() -> (Self, Command<Message>) {
    method title (line 68) | fn title(&self) -> String {
    method update (line 77) | fn update(&mut self, message: Message) -> Command<Message> {
    method view (line 188) | fn view(&self) -> Element<'_, Message> {
    method subscription (line 243) | fn subscription(&self) -> Subscription<Message> {
  type State (line 38) | struct State {
  type Message (line 47) | enum Message {
  type Task (line 269) | struct Task {
    method text_input_id (line 296) | fn text_input_id(i: usize) -> widget::Id {
    method new (line 300) | fn new(description: String) -> Self {
    method update (line 309) | fn update(&mut self, message: TaskMessage) {
    method view (line 329) | fn view(&self, i: usize) -> Element<'_, TaskMessage> {
  type TaskState (line 280) | pub enum TaskState {
  type TaskMessage (line 287) | pub enum TaskMessage {
  function view_controls (line 372) | fn view_controls(tasks: &[Task], current_filter: Filter) -> Element<'_, ...
  type Filter (line 406) | pub enum Filter {
    method matches (line 414) | fn matches(self, task: &Task) -> bool {
  function loading_message (line 423) | fn loading_message<'a>() -> Element<'a, Message> {
  function empty_message (line 427) | fn empty_message(message: &str) -> Element<'_, Message> {
  function icon (line 441) | fn icon(unicode: char) -> Text<'static> {
  function edit_icon (line 449) | fn edit_icon() -> Text<'static> {
  function delete_icon (line 453) | fn delete_icon() -> Text<'static> {
  function subtle (line 457) | fn subtle(theme: &Theme) -> text::Style {
  type SavedState (line 465) | struct SavedState {
    method path (line 485) | fn path() -> std::path::PathBuf {
    method load (line 498) | async fn load() -> Result<SavedState, LoadError> {
    method save (line 506) | async fn save(self) -> Result<(), SaveError> {
    method storage (line 534) | fn storage() -> Option<web_sys::Storage> {
    method load (line 540) | async fn load() -> Result<SavedState, LoadError> {
    method save (line 551) | async fn save(self) -> Result<(), SaveError> {
  type LoadError (line 472) | enum LoadError {
  type SaveError (line 478) | enum SaveError {
  function presets (line 566) | fn presets() -> impl IntoIterator<Item = Preset<Todos, Message>> {
  function simulator (line 600) | fn simulator(todos: &Todos) -> Simulator<'_, Message> {
  function it_creates_a_new_task (line 612) | fn it_creates_a_new_task() -> Result<(), Error> {
  function it_passes_the_ice_tests (line 640) | fn it_passes_the_ice_tests() -> Result<(), Error> {

FILE: examples/tooltip/src/main.rs
  function main (line 7) | pub fn main() -> iced::Result {
  type Tooltip (line 12) | struct Tooltip {
    method update (line 24) | fn update(&mut self, message: Message) {
    method view (line 43) | fn view(&self) -> Element<'_, Message> {
  type Message (line 18) | enum Message {
  function position_to_text (line 66) | fn position_to_text<'a>(position: Position) -> &'a str {

FILE: examples/tour/src/main.rs
  function main (line 8) | pub fn main() -> iced::Result {
  type Tour (line 24) | pub struct Tour {
    method title (line 62) | fn title(&self) -> String {
    method update (line 80) | fn update(&mut self, event: Message) {
    method view (line 142) | fn view(&self) -> Element<'_, Message> {
    method can_continue (line 181) | fn can_continue(&self) -> bool {
    method welcome (line 197) | fn welcome(&self) -> Column<'_, Message> {
    method slider (line 235) | fn slider(&self) -> Column<'_, Message> {
    method rows_and_columns (line 249) | fn rows_and_columns(&self) -> Column<'_, Message> {
    method text (line 292) | fn text(&self) -> Column<'_, Message> {
    method radio (line 328) | fn radio(&self) -> Column<'_, Message> {
    method toggler (line 358) | fn toggler(&self) -> Column<'_, Message> {
    method image (line 371) | fn image(&self) -> Column<'_, Message> {
    method scrollable (line 388) | fn scrollable(&self) -> Column<'_, Message> {
    method text_input (line 407) | fn text_input(&self) -> Column<'_, Message> {
    method debugger (line 455) | fn debugger(&self) -> Column<'_, Message> {
    method end (line 473) | fn end(&self) -> Column<'_, Message> {
    method container (line 479) | fn container(title: &str) -> Column<'_, Message> {
  type Message (line 42) | pub enum Message {
  type Screen (line 485) | enum Screen {
    constant ALL (line 500) | const ALL: &'static [Self] = &[
    method next (line 514) | pub fn next(self) -> Option<Screen> {
    method previous (line 527) | pub fn previous(self) -> Option<Screen> {
  function ferris (line 542) | fn ferris<'a>(width: u32, filter_method: image::FilterMethod) -> Contain...
  function padded_button (line 556) | fn padded_button<Message: Clone>(label: &str) -> Button<'_, Message> {
  function color_slider (line 560) | fn color_slider<'a>(
  type Language (line 571) | pub enum Language {
    method all (line 581) | fn all() -> [Language; 6] {
  method from (line 594) | fn from(language: Language) -> String {
  type Layout (line 607) | pub enum Layout {
  method default (line 613) | fn default() -> Self {

FILE: examples/url_handler/src/main.rs
  function main (line 5) | pub fn main() -> iced::Result {
  type App (line 12) | struct App {
    method update (line 22) | fn update(&mut self, message: Message) {
    method subscription (line 30) | fn subscription(&self) -> Subscription<Message> {
    method view (line 34) | fn view(&self) -> Element<'_, Message> {
  type Message (line 17) | enum Message {

FILE: examples/vectorial_text/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type VectorialText (line 17) | struct VectorialText {
    method update (line 30) | fn update(&mut self, message: Message) {
    method view (line 49) | fn view(&self) -> Element<'_, Message> {
  type Message (line 22) | enum Message {
  type State (line 95) | struct State {
    method new (line 104) | pub fn new() -> Self {
    type State (line 116) | type State = ();
    method draw (line 118) | fn draw(
  method default (line 155) | fn default() -> Self {

FILE: examples/websocket/src/echo.rs
  function connect (line 14) | pub fn connect() -> impl Sipper<Never, Event> {
  type Event (line 63) | pub enum Event {
  type Connection (line 70) | pub struct Connection(mpsc::Sender<Message>);
    method send (line 73) | pub fn send(&mut self, message: Message) {
  type Message (line 81) | pub enum Message {
    method new (line 88) | pub fn new(message: &str) -> Option<Self> {
    method connected (line 96) | pub fn connected() -> Self {
    method disconnected (line 100) | pub fn disconnected() -> Self {
    method as_str (line 104) | pub fn as_str(&self) -> &str {
    method fmt (line 114) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function into_fragment (line 120) | fn into_fragment(self) -> text::Fragment<'a> {

FILE: examples/websocket/src/echo/server.rs
  function run (line 29) | pub async fn run() {
  function user_connected (line 37) | async fn user_connected(ws: WebSocket) {

FILE: examples/websocket/src/main.rs
  function main (line 6) | pub fn main() -> iced::Result {
  type WebSocket (line 12) | struct WebSocket {
    method new (line 26) | fn new() -> (Self, Task<Message>) {
    method update (line 40) | fn update(&mut self, message: Message) -> Task<Message> {
    method subscription (line 81) | fn subscription(&self) -> Subscription<Message> {
    method view (line 85) | fn view(&self) -> Element<'_, Message> {
  type Message (line 19) | enum Message {
  type State (line 121) | enum State {
  constant MESSAGE_LOG (line 126) | const MESSAGE_LOG: &str = "message_log";

FILE: futures/src/backend/native/smol.rs
  type Executor (line 5) | pub struct Executor;
    method new (line 8) | fn new() -> Result<Self, futures::io::Error> {
    method spawn (line 12) | fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
    method block_on (line 16) | fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
  function every (line 33) | pub fn every(duration: Duration) -> Subscription<Instant> {
  function repeat (line 45) | pub fn repeat<F, T>(f: fn() -> F, interval: Duration) -> Subscription<T>

FILE: futures/src/backend/native/thread_pool.rs
  type Executor (line 4) | pub type Executor = futures::executor::ThreadPool;
    method new (line 7) | fn new() -> Result<Self, futures::io::Error> {
    method spawn (line 11) | fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
    method block_on (line 15) | fn block_on<T>(&self, future: impl Future<Output = T>) -> T {

FILE: futures/src/backend/native/tokio.rs
  type Executor (line 4) | pub type Executor = tokio::runtime::Runtime;
    method new (line 7) | fn new() -> Result<Self, futures::io::Error> {
    method spawn (line 12) | fn spawn(&self, future: impl Future<Output = ()> + Send + 'static) {
    method enter (line 16) | fn enter<R>(&self, f: impl FnOnce() -> R) -> R {
    method block_on (line 21) | fn block_on<T>(&self, future: impl Future<Output = T>) -> T {
  function every (line 38) | pub fn every(duration: Duration) -> Subscription<Instant> {
  function repeat (line 59) | pub fn repeat<F, T>(f: fn() -> F, interval: Duration) -> Subscription<T>

FILE: futures/src/backend/null.rs
  type Executor (line 6) | pub struct Executor;
    method new (line 9) | fn new() -> Result<Self, futures::io::Error> {
    method spawn (line 13) | fn spawn(&self, _future: impl Future<Output = ()> + MaybeSend + 'stati...
    method block_on (line 16) | fn block_on<T>(&self, _future: impl Future<Output = T>) -> T {

FILE: futures/src/backend/wasm/wasm_bindgen.rs
  type Executor (line 5) | pub struct Executor;
    method new (line 8) | fn new() -> Result<Self, futures::io::Error> {
    method spawn (line 12) | fn spawn(&self, future: impl futures::Future<Output = ()> + 'static) {
  function every (line 27) | pub fn every(duration: std::time::Duration) -> Subscription<Instant> {

FILE: futures/src/event.rs
  function listen (line 11) | pub fn listen() -> Subscription<Event> {
  function listen_with (line 26) | pub fn listen_with<Message>(
  function listen_raw (line 55) | pub fn listen_raw<Message>(
  function listen_url (line 82) | pub fn listen_url() -> Subscription<String> {

FILE: futures/src/executor.rs
  type Executor (line 5) | pub trait Executor: Sized {
    method new (line 7) | fn new() -> Result<Self, futures::io::Error>
    method spawn (line 12) | fn spawn(&self, future: impl Future<Output = ()> + MaybeSend + 'static);
    method block_on (line 16) | fn block_on<T>(&self, future: impl Future<Output = T>) -> T;
    method enter (line 24) | fn enter<R>(&self, f: impl FnOnce() -> R) -> R {

FILE: futures/src/keyboard.rs
  function listen (line 7) | pub fn listen() -> Subscription<Event> {

FILE: futures/src/lib.rs
  type BoxFuture (line 33) | pub type BoxFuture<T> = futures::future::BoxFuture<'static, T>;
  type BoxStream (line 39) | pub type BoxStream<T> = futures::stream::BoxStream<'static, T>;
  function boxed_stream (line 45) | pub fn boxed_stream<T, S>(stream: S) -> BoxStream<T>
  type BoxFuture (line 59) | pub type BoxFuture<T> = futures::future::LocalBoxFuture<'static, T>;
  type BoxStream (line 65) | pub type BoxStream<T> = futures::stream::LocalBoxStream<'static, T>;
  function boxed_stream (line 71) | pub fn boxed_stream<T, S>(stream: S) -> BoxStream<T>

FILE: futures/src/maybe.rs
  type MaybeSend (line 6) | pub trait MaybeSend: Send {}
  type MaybeSync (line 13) | pub trait MaybeSync: Sync {}
  type MaybeSend (line 23) | pub trait MaybeSend {}
  type MaybeSync (line 30) | pub trait MaybeSync {}

FILE: futures/src/runtime.rs
  type Runtime (line 15) | pub struct Runtime<Executor, Sender, Message> {
  function new (line 33) | pub fn new(executor: Executor, sender: Sender) -> Self {
  function enter (line 45) | pub fn enter<R>(&self, f: impl FnOnce() -> R) -> R {
  function block_on (line 51) | pub fn block_on<T>(&mut self, future: impl Future<Output = T>) -> T {
  function run (line 61) | pub fn run(&mut self, stream: BoxStream<Message>) {
  function send (line 76) | pub fn send(&mut self, message: Message) {
  function track (line 91) | pub fn track(
  function broadcast (line 115) | pub fn broadcast(&mut self, event: subscription::Event) {

FILE: futures/src/stream.rs
  function channel (line 11) | pub fn channel<T>(size: usize, f: impl AsyncFnOnce(mpsc::Sender<T>)) -> ...
  function try_channel (line 21) | pub fn try_channel<T, E>(

FILE: futures/src/subscription.rs
  type Event (line 17) | pub enum Event {
  type PlatformSpecific (line 40) | pub enum PlatformSpecific {
  type MacOS (line 47) | pub enum MacOS {
  type EventStream (line 59) | pub type EventStream = BoxStream<Event>;
  type Hasher (line 62) | pub type Hasher = rustc_hash::FxHasher;
  type Subscription (line 121) | pub struct Subscription<T> {
  function none (line 127) | pub fn none() -> Self {
  function run (line 203) | pub fn run<S>(builder: fn() -> S) -> Self
  function run_with (line 219) | pub fn run_with<D, S>(data: D, builder: fn(&D) -> S) -> Self
  function batch (line 233) | pub fn batch(subscriptions: impl IntoIterator<Item = Subscription<T>>) -...
  function with (line 245) | pub fn with<A>(self, value: A) -> Subscription<(A, T)>
  function map (line 298) | pub fn map<F, A>(self, f: F) -> Subscription<A>
  function filter_map (line 354) | pub fn filter_map<F, A>(mut self, f: F) -> Subscription<A>
  function units (line 414) | pub fn units(&self) -> usize {
  function from_recipe (line 420) | pub fn from_recipe<T>(recipe: impl Recipe<Output = T> + 'static) -> Subs...
  function into_recipes (line 427) | pub fn into_recipes<T>(subscription: Subscription<T>) -> Vec<Box<dyn Rec...
  function fmt (line 432) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Recipe (line 442) | pub trait Recipe {
    method hash (line 450) | fn hash(&self, state: &mut Hasher);
    method stream (line 454) | fn stream(self: Box<Self>, input: EventStream) -> BoxStream<Self::Outp...
    type Output (line 490) | type Output = T;
    method hash (line 492) | fn hash(&self, state: &mut Hasher) {
    method stream (line 497) | fn stream(self: Box<Self>, input: EventStream) -> BoxStream<Self::Outp...
  function filter_map (line 458) | pub fn filter_map<I, F, T>(id: I, f: F) -> Subscription<T>
  type Runner (line 475) | struct Runner<I, F, S, T>
  function check_zero_sized (line 502) | const fn check_zero_sized<T>() {

FILE: futures/src/subscription/tracker.rs
  type Tracker (line 18) | pub struct Tracker {
    method new (line 30) | pub fn new() -> Self {
    method update (line 55) | pub fn update<Message, Receiver>(
    method broadcast (line 135) | pub fn broadcast(&mut self, event: Event) {
  type Execution (line 23) | pub struct Execution {

FILE: graphics/src/antialiasing.rs
  type Antialiasing (line 3) | pub enum Antialiasing {
    method sample_count (line 16) | pub fn sample_count(self) -> u32 {

FILE: graphics/src/cache.rs
  type Cache (line 10) | pub struct Cache<T> {
  function new (line 17) | pub fn new() -> Self {
  function with_group (line 30) | pub fn with_group(group: Group) -> Self {
  function group (line 43) | pub fn group(&self) -> Group {
  function put (line 52) | pub fn put(&self, value: T) {
  function state (line 57) | pub fn state(&self) -> &RefCell<State<T>> {
  function clear (line 62) | pub fn clear(&self) {
  type Group (line 83) | pub struct Group {
    method unique (line 90) | pub fn unique() -> Self {
    method is_singleton (line 108) | pub fn is_singleton(self) -> bool {
    method singleton (line 112) | fn singleton() -> Self {
  function fmt (line 124) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 141) | fn default() -> Self {
  type State (line 148) | pub enum State<T> {
  type Cached (line 162) | pub trait Cached: Sized {
    method load (line 169) | fn load(cache: &Self::Cache) -> Self;
    method cache (line 174) | fn cache(self, group: Group, previous: Option<Self::Cache>) -> Self::C...
    type Cache (line 179) | type Cache = ();
    method load (line 181) | fn load(_cache: &Self::Cache) -> Self {}
    method cache (line 183) | fn cache(self, _group: Group, _previous: Option<Self::Cache>) -> Self:...

FILE: graphics/src/color.rs
  type Packed (line 9) | pub struct Packed([f32; 4]);
    method components (line 13) | pub fn components(self) -> [f32; 4] {
  constant GAMMA_CORRECTION (line 19) | pub const GAMMA_CORRECTION: bool = internal::GAMMA_CORRECTION;
  function pack (line 22) | pub fn pack(color: impl Into<Color>) -> Packed {
  constant GAMMA_CORRECTION (line 30) | pub const GAMMA_CORRECTION: bool = true;
  function pack (line 32) | pub fn pack(color: Color) -> [f32; 4] {
  constant GAMMA_CORRECTION (line 41) | pub const GAMMA_CORRECTION: bool = false;
  function pack (line 43) | pub fn pack(color: Color) -> [f32; 4] {

FILE: graphics/src/compositor.rs
  type Compositor (line 16) | pub trait Compositor: Sized {
    method new (line 24) | fn new(
    method with_backend (line 37) | fn with_backend(
    method create_renderer (line 46) | fn create_renderer(&self, settings: renderer::Settings) -> Self::Rende...
    method create_surface (line 51) | fn create_surface<W: Window + Clone>(
    method configure_surface (line 61) | fn configure_surface(&mut self, surface: &mut Self::Surface, width: u3...
    method information (line 64) | fn information(&self) -> Information;
    method load_font (line 67) | fn load_font(&mut self, font: Cow<'static, [u8]>) -> Result<(), font::...
    method list_fonts (line 78) | fn list_fonts(&mut self) -> Result<Vec<font::Family>, font::Error> {
    method present (line 94) | fn present(
    method screenshot (line 107) | fn screenshot(
    type Renderer (line 200) | type Renderer = ();
    type Surface (line 201) | type Surface = ();
    method with_backend (line 203) | async fn with_backend(
    method create_renderer (line 213) | fn create_renderer(&self, _settings: renderer::Settings) -> Self::Rend...
    method create_surface (line 215) | fn create_surface<W: Window + Clone>(
    method configure_surface (line 223) | fn configure_surface(&mut self, _surface: &mut Self::Surface, _width: ...
    method load_font (line 225) | fn load_font(&mut self, _font: Cow<'static, [u8]>) -> Result<(), font:...
    method list_fonts (line 229) | fn list_fonts(&mut self) -> Result<Vec<font::Family>, font::Error> {
    method information (line 233) | fn information(&self) -> Information {
    method present (line 240) | fn present(
    method screenshot (line 251) | fn screenshot(
  type Settings (line 117) | pub struct Settings {
    method default (line 130) | fn default() -> Settings {
    method from (line 139) | fn from(settings: &core::Settings) -> Self {
  type Window (line 151) | pub trait Window: HasWindowHandle + HasDisplayHandle + MaybeSend + Maybe...
  type Display (line 159) | pub trait Display: HasDisplayHandle + MaybeSend + MaybeSync + 'static {}
  type Default (line 164) | pub trait Default {
    type Compositor (line 263) | type Compositor = ();
  type SurfaceError (line 171) | pub enum SurfaceError {
  type Information (line 191) | pub struct Information {

FILE: graphics/src/damage.rs
  function diff (line 5) | pub fn diff<T>(
  function list (line 30) | pub fn list<T>(
  function group (line 47) | pub fn group(mut damage: Vec<Rectangle>, bounds: Rectangle) -> Vec<Recta...

FILE: graphics/src/error.rs
  type Error (line 5) | pub enum Error {
  type Reason (line 34) | pub enum Reason {

FILE: graphics/src/geometry.rs
  type Renderer (line 26) | pub trait Renderer: core::Renderer {
    method new_frame (line 34) | fn new_frame(&self, bounds: Rectangle) -> Self::Frame;
    method draw_geometry (line 37) | fn draw_geometry(&mut self, geometry: Self::Geometry);
    type Geometry (line 42) | type Geometry = ();
    type Frame (line 43) | type Frame = ();
    method new_frame (line 45) | fn new_frame(&self, _bounds: Rectangle) -> Self::Frame {}
    method draw_geometry (line 47) | fn draw_geometry(&mut self, _geometry: Self::Geometry) {}

FILE: graphics/src/geometry/cache.rs
  type Cache (line 11) | pub struct Cache<Renderer>
  type Data (line 19) | struct Data<T> {
  function new (line 29) | pub fn new() -> Self {
  function with_group (line 41) | pub fn with_group(group: Group) -> Self {
  function clear (line 48) | pub fn clear(&self) {
  function draw (line 62) | pub fn draw(
  function draw_with_bounds (line 76) | pub fn draw_with_bounds(
  function fmt (line 116) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 125) | fn default() -> Self {

FILE: graphics/src/geometry/fill.rs
  type Fill (line 11) | pub struct Fill {
    method from (line 38) | fn from(color: Color) -> Fill {
    method from (line 47) | fn from(gradient: Gradient) -> Self {
    method from (line 56) | fn from(gradient: gradient::Linear) -> Self {
  method default (line 29) | fn default() -> Self {
  type Rule (line 72) | pub enum Rule {

FILE: graphics/src/geometry/frame.rs
  type Frame (line 6) | pub struct Frame<Renderer>
  function new (line 21) | pub fn new(renderer: &Renderer, size: Size) -> Self {
  function with_bounds (line 26) | pub fn with_bounds(renderer: &Renderer, bounds: Rectangle) -> Self {
  function width (line 33) | pub fn width(&self) -> f32 {
  function height (line 38) | pub fn height(&self) -> f32 {
  function size (line 43) | pub fn size(&self) -> Size {
  function center (line 48) | pub fn center(&self) -> Point {
  function fill (line 54) | pub fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
  function fill_rectangle (line 60) | pub fn fill_rectangle(&mut self, top_left: Point, size: Size, fill: impl...
  function stroke (line 66) | pub fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
  function stroke_rectangle (line 72) | pub fn stroke_rectangle<'a>(
  function fill_text (line 87) | pub fn fill_text(&mut self, text: impl Into<Text>) {
  function draw_image (line 93) | pub fn draw_image(&mut self, bounds: Rectangle, image: impl Into<Image>) {
  function draw_svg (line 99) | pub fn draw_svg(&mut self, bounds: Rectangle, svg: impl Into<Svg>) {
  function with_save (line 109) | pub fn with_save<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
  function push_transform (line 120) | pub fn push_transform(&mut self) {
  function pop_transform (line 125) | pub fn pop_transform(&mut self) {
  function with_clip (line 136) | pub fn with_clip<R>(&mut self, region: Rectangle, f: impl FnOnce(&mut Se...
  function draft (line 150) | fn draft(&mut self, clip_bounds: Rectangle) -> Self {
  function paste (line 157) | fn paste(&mut self, frame: Self) {
  function translate (line 162) | pub fn translate(&mut self, translation: Vector) {
  function rotate (line 167) | pub fn rotate(&mut self, angle: impl Into<Radians>) {
  function scale (line 172) | pub fn scale(&mut self, scale: impl Into<f32>) {
  function scale_nonuniform (line 177) | pub fn scale_nonuniform(&mut self, scale: impl Into<Vector>) {
  function into_geometry (line 182) | pub fn into_geometry(self) -> Renderer::Geometry {
  type Backend (line 192) | pub trait Backend: Sized {
    method width (line 195) | fn width(&self) -> f32;
    method height (line 196) | fn height(&self) -> f32;
    method size (line 197) | fn size(&self) -> Size;
    method center (line 198) | fn center(&self) -> Point;
    method push_transform (line 200) | fn push_transform(&mut self);
    method pop_transform (line 201) | fn pop_transform(&mut self);
    method translate (line 203) | fn translate(&mut self, translation: Vector);
    method rotate (line 204) | fn rotate(&mut self, angle: impl Into<Radians>);
    method scale (line 205) | fn scale(&mut self, scale: impl Into<f32>);
    method scale_nonuniform (line 206) | fn scale_nonuniform(&mut self, scale: impl Into<Vector>);
    method draft (line 208) | fn draft(&mut self, clip_bounds: Rectangle) -> Self;
    method paste (line 209) | fn paste(&mut self, frame: Self);
    method stroke (line 211) | fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>);
    method stroke_rectangle (line 212) | fn stroke_rectangle<'a>(&mut self, top_left: Point, size: Size, stroke...
    method stroke_text (line 213) | fn stroke_text<'a>(&mut self, text: impl Into<Text>, stroke: impl Into...
    method fill (line 215) | fn fill(&mut self, path: &Path, fill: impl Into<Fill>);
    method fill_text (line 216) | fn fill_text(&mut self, text: impl Into<Text>);
    method fill_rectangle (line 217) | fn fill_rectangle(&mut self, top_left: Point, size: Size, fill: impl I...
    method draw_image (line 219) | fn draw_image(&mut self, bounds: Rectangle, image: impl Into<Image>);
    method draw_svg (line 220) | fn draw_svg(&mut self, bounds: Rectangle, svg: impl Into<Svg>);
    method into_geometry (line 222) | fn into_geometry(self) -> Self::Geometry;
    type Geometry (line 227) | type Geometry = ();
    method width (line 229) | fn width(&self) -> f32 {
    method height (line 233) | fn height(&self) -> f32 {
    method size (line 237) | fn size(&self) -> Size {
    method center (line 241) | fn center(&self) -> Point {
    method push_transform (line 245) | fn push_transform(&mut self) {}
    method pop_transform (line 246) | fn pop_transform(&mut self) {}
    method translate (line 248) | fn translate(&mut self, _translation: Vector) {}
    method rotate (line 249) | fn rotate(&mut self, _angle: impl Into<Radians>) {}
    method scale (line 250) | fn scale(&mut self, _scale: impl Into<f32>) {}
    method scale_nonuniform (line 251) | fn scale_nonuniform(&mut self, _scale: impl Into<Vector>) {}
    method draft (line 253) | fn draft(&mut self, _clip_bounds: Rectangle) -> Self {}
    method paste (line 254) | fn paste(&mut self, _frame: Self) {}
    method stroke (line 256) | fn stroke<'a>(&mut self, _path: &Path, _stroke: impl Into<Stroke<'a>>) {}
    method stroke_rectangle (line 257) | fn stroke_rectangle<'a>(
    method stroke_text (line 264) | fn stroke_text<'a>(&mut self, _text: impl Into<Text>, _stroke: impl In...
    method fill (line 266) | fn fill(&mut self, _path: &Path, _fill: impl Into<Fill>) {}
    method fill_text (line 267) | fn fill_text(&mut self, _text: impl Into<Text>) {}
    method fill_rectangle (line 268) | fn fill_rectangle(&mut self, _top_left: Point, _size: Size, _fill: imp...
    method draw_image (line 270) | fn draw_image(&mut self, _bounds: Rectangle, _image: impl Into<Image>) {}
    method draw_svg (line 271) | fn draw_svg(&mut self, _bounds: Rectangle, _svg: impl Into<Svg>) {}
    method into_geometry (line 273) | fn into_geometry(self) -> Self::Geometry {}

FILE: graphics/src/geometry/path.rs
  type Path (line 19) | pub struct Path {
    method new (line 27) | pub fn new(f: impl FnOnce(&mut Builder)) -> Self {
    method line (line 38) | pub fn line(from: Point, to: Point) -> Self {
    method rectangle (line 47) | pub fn rectangle(top_left: Point, size: Size) -> Self {
    method rounded_rectangle (line 53) | pub fn rounded_rectangle(top_left: Point, size: Size, radius: border::...
    method circle (line 59) | pub fn circle(center: Point, radius: f32) -> Self {
    method raw (line 68) | pub fn raw(&self) -> &lyon_path::Path {
    method transform (line 74) | pub fn transform(&self, transform: &lyon_path::math::Transform) -> Path {

FILE: graphics/src/geometry/path/arc.rs
  type Arc (line 6) | pub struct Arc {
  type Elliptical (line 19) | pub struct Elliptical {
    method from (line 33) | fn from(arc: Arc) -> Elliptical {

FILE: graphics/src/geometry/path/builder.rs
  type Builder (line 13) | pub struct Builder {
    method new (line 19) | pub fn new() -> Builder {
    method move_to (line 27) | pub fn move_to(&mut self, point: Point) {
    method line_to (line 34) | pub fn line_to(&mut self, point: Point) {
    method arc (line 41) | pub fn arc(&mut self, arc: Arc) {
    method arc_to (line 58) | pub fn arc_to(&mut self, a: Point, b: Point, radius: f32) {
    method ellipse (line 104) | pub fn ellipse(&mut self, arc: arc::Elliptical) {
    method bezier_curve_to (line 124) | pub fn bezier_curve_to(&mut self, control_a: Point, control_b: Point, ...
    method quadratic_curve_to (line 135) | pub fn quadratic_curve_to(&mut self, control: Point, to: Point) {
    method rectangle (line 145) | pub fn rectangle(&mut self, top_left: Point, size: Size) {
    method rounded_rectangle (line 159) | pub fn rounded_rectangle(&mut self, top_left: Point, size: Size, radiu...
    method circle (line 223) | pub fn circle(&mut self, center: Point, radius: f32) {
    method close (line 235) | pub fn close(&mut self) {
    method build (line 241) | pub fn build(self) -> Path {
  method default (line 249) | fn default() -> Self {

FILE: graphics/src/geometry/stroke.rs
  type Stroke (line 10) | pub struct Stroke<'a> {
  function with_color (line 28) | pub fn with_color(self, color: Color) -> Self {
  function with_width (line 36) | pub fn with_width(self, width: f32) -> Self {
  function with_line_cap (line 41) | pub fn with_line_cap(self, line_cap: LineCap) -> Self {
  function with_line_join (line 46) | pub fn with_line_join(self, line_join: LineJoin) -> Self {
  method default (line 52) | fn default() -> Self {
  type LineCap (line 65) | pub enum LineCap {
  type LineJoin (line 80) | pub enum LineJoin {
  type LineDash (line 92) | pub struct LineDash<'a> {

FILE: graphics/src/geometry/style.rs
  type Style (line 6) | pub enum Style {
    method from (line 15) | fn from(color: Color) -> Self {
    method from (line 21) | fn from(gradient: Gradient) -> Self {

FILE: graphics/src/geometry/text.rs
  type Text (line 10) | pub struct Text {
    method draw_with (line 52) | pub fn draw_with(&self, mut f: impl FnMut(Path, Color)) {
    method from (line 178) | fn from(content: String) -> Text {
    method from (line 187) | fn from(content: &str) -> Text {
  method default (line 159) | fn default() -> Text {

FILE: graphics/src/gradient.rs
  type Gradient (line 16) | pub enum Gradient {
    method from (line 23) | fn from(gradient: Linear) -> Self {
    method pack (line 30) | pub fn pack(&self) -> Packed {
  type Linear (line 39) | pub struct Linear {
    method new (line 52) | pub fn new(start: Point, end: Point) -> Self {
    method add_stop (line 65) | pub fn add_stop(mut self, offset: f32, color: Color) -> Self {
    method add_stops (line 85) | pub fn add_stops(mut self, stops: impl IntoIterator<Item = ColorStop>)...
    method pack (line 94) | pub fn pack(&self) -> Packed {
  type Packed (line 129) | pub struct Packed {
  function pack (line 138) | pub fn pack(gradient: &core::Gradient, bounds: Rectangle) -> Packed {
  function pack_f16s (line 177) | fn pack_f16s(f: [f16; 2]) -> u32 {

FILE: graphics/src/image.rs
  type Image (line 12) | pub enum Image {
    method bounds (line 30) | pub fn bounds(&self) -> Rectangle {
  type Buffer (line 40) | pub type Buffer = ::image::ImageBuffer<::image::Rgba<u8>, Bytes>;
  function load (line 46) | pub fn load(handle: &image::Handle) -> Result<Buffer, image::Error> {
  function to_error (line 156) | fn to_error(error: ::image::ImageError) -> image::Error {

FILE: graphics/src/image/storage.rs
  type Storage (line 7) | pub trait Storage {
    method upload (line 15) | fn upload(
    method remove (line 24) | fn remove(&mut self, entry: &Self::Entry, state: &mut Self::State<'_>);
  type Entry (line 28) | pub trait Entry: Debug {
    method size (line 30) | fn size(&self) -> Size<u32>;

FILE: graphics/src/layer.rs
  type Layer (line 8) | pub trait Layer: Default {
    method with_bounds (line 10) | fn with_bounds(bounds: Rectangle) -> Self;
    method bounds (line 13) | fn bounds(&self) -> Rectangle;
    method flush (line 19) | fn flush(&mut self);
    method resize (line 22) | fn resize(&mut self, bounds: Rectangle);
    method reset (line 25) | fn reset(&mut self);
    method start (line 37) | fn start(&self) -> usize;
    method end (line 40) | fn end(&self) -> usize;
    method merge (line 43) | fn merge(&mut self, _layer: &mut Self);
  type Stack (line 48) | pub struct Stack<T: Layer> {
  function new (line 58) | pub fn new() -> Self {
  function current_mut (line 71) | pub fn current_mut(&mut self) -> (&mut T, Transformation) {
  function transformation (line 79) | pub fn transformation(&self) -> Transformation {
  function push_clip (line 85) | pub fn push_clip(&mut self, bounds: Rectangle) {
  function pop_clip (line 103) | pub fn pop_clip(&mut self) {
  function push_transformation (line 115) | pub fn push_transformation(&mut self, transformation: Transformation) {
  function pop_transformation (line 121) | pub fn pop_transformation(&mut self) {
  function iter (line 126) | pub fn iter(&self) -> impl Iterator<Item = &T> {
  function as_slice (line 131) | pub fn as_slice(&self) -> &[T] {
  function flush (line 136) | pub fn flush(&mut self) {
  function merge (line 143) | pub fn merge(&mut self) {
  function reset (line 205) | pub fn reset(&mut self, new_bounds: Rectangle) {
  method default (line 218) | fn default() -> Self {

FILE: graphics/src/mesh.rs
  type Mesh (line 13) | pub enum Mesh {
    method indices (line 40) | pub fn indices(&self) -> &[u32] {
    method transformation (line 48) | pub fn transformation(&self) -> Transformation {
    method clip_bounds (line 57) | pub fn clip_bounds(&self) -> Rectangle {
  type Indexed (line 75) | pub struct Indexed<T> {
  type SolidVertex2D (line 88) | pub struct SolidVertex2D {
  type GradientVertex2D (line 99) | pub struct GradientVertex2D {
  type AttributeCount (line 109) | pub struct AttributeCount {
  function attribute_count_of (line 127) | pub fn attribute_count_of(meshes: &[Mesh]) -> AttributeCount {
  type Cache (line 150) | pub struct Cache {
    method new (line 162) | pub fn new(meshes: Arc<[Mesh]>) -> Self {
    method id (line 173) | pub fn id(&self) -> Id {
    method version (line 178) | pub fn version(&self) -> usize {
    method batch (line 183) | pub fn batch(&self) -> &Arc<[Mesh]> {
    method is_empty (line 188) | pub fn is_empty(&self) -> bool {
    method update (line 193) | pub fn update(&mut self, meshes: Arc<[Mesh]>) {
  type Id (line 158) | pub struct Id(u64);
  type Renderer (line 200) | pub trait Renderer {
    method draw_mesh (line 202) | fn draw_mesh(&mut self, mesh: Mesh);
    method draw_mesh_cache (line 205) | fn draw_mesh_cache(&mut self, cache: Cache);

FILE: graphics/src/shell.rs
  type Shell (line 6) | pub struct Shell(Arc<dyn Notifier>);
    method new (line 10) | pub fn new(notifier: impl Notifier) -> Self {
    method headless (line 15) | pub fn headless() -> Self {
    method tick (line 29) | pub fn tick(&self) {
    method request_redraw (line 34) | pub fn request_redraw(&self) {
    method invalidate_layout (line 39) | pub fn invalidate_layout(&self) {
  type Notifier (line 45) | pub trait Notifier: Send + Sync + 'static {
    method tick (line 48) | fn tick(&self);
    method request_redraw (line 51) | fn request_redraw(&self);
    method invalidate_layout (line 54) | fn invalidate_layout(&self);

FILE: graphics/src/text.rs
  type Text (line 23) | pub enum Text {
    method visible_bounds (line 79) | pub fn visible_bounds(&self) -> Option<Rectangle> {
  constant FIRA_SANS_REGULAR (line 116) | pub const FIRA_SANS_REGULAR: &[u8] = include_bytes!("../fonts/FiraSans-R...
  function font_system (line 119) | pub fn font_system() -> &'static RwLock<FontSystem> {
  type FontSystem (line 146) | pub struct FontSystem {
    method raw (line 154) | pub fn raw(&mut self) -> &mut cosmic_text::FontSystem {
    method load_font (line 159) | pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
    method families (line 180) | pub fn families(&self) -> impl Iterator<Item = &str> {
    method version (line 191) | pub fn version(&self) -> Version {
  type Version (line 198) | pub struct Version(u32);
  type Raw (line 202) | pub struct Raw {
  method eq (line 214) | fn eq(&self, _other: &Self) -> bool {
  function measure (line 224) | pub fn measure(buffer: &cosmic_text::Buffer) -> (Size, bool) {
  function align (line 241) | pub fn align(
  function to_attributes (line 278) | pub fn to_attributes(font: Font) -> cosmic_text::Attrs<'static> {
  function to_family (line 286) | fn to_family(family: font::Family) -> cosmic_text::Family<'static> {
  function to_weight (line 297) | fn to_weight(weight: font::Weight) -> cosmic_text::Weight {
  function to_stretch (line 311) | fn to_stretch(stretch: font::Stretch) -> cosmic_text::Stretch {
  function to_style (line 325) | fn to_style(style: font::Style) -> cosmic_text::Style {
  function to_align (line 333) | fn to_align(alignment: Alignment) -> Option<cosmic_text::Align> {
  function to_shaping (line 344) | pub fn to_shaping(shaping: Shaping, text: &str) -> cosmic_text::Shaping {
  function to_wrap (line 359) | pub fn to_wrap(wrapping: Wrapping) -> cosmic_text::Wrap {
  function to_ellipsize (line 369) | pub fn to_ellipsize(ellipsis: Ellipsis, max_height: f32) -> cosmic_text:...
  function to_color (line 381) | pub fn to_color(color: Color) -> cosmic_text::Color {
  function hint_factor (line 388) | pub fn hint_factor(_size: Pixels, _scale_factor: Option<f32>) -> Option<...
  type Renderer (line 404) | pub trait Renderer {
    method fill_raw (line 406) | fn fill_raw(&mut self, raw: Raw);

FILE: graphics/src/text/cache.rs
  type Cache (line 11) | pub struct Cache {
    method new (line 19) | pub fn new() -> Self {
    method get (line 24) | pub fn get(&self, key: &KeyHash) -> Option<&Entry> {
    method allocate (line 29) | pub fn allocate(
    method trim (line 92) | pub fn trim(&mut self) {
  type Key (line 105) | pub struct Key<'a> {
  function hash (line 127) | fn hash<H: Hasher>(self, mut hasher: H) -> KeyHash {
  type KeyHash (line 142) | pub type KeyHash = u64;
  type Entry (line 146) | pub struct Entry {

FILE: graphics/src/text/editor.rs
  type Editor (line 18) | pub struct Editor(Option<Arc<Internal>>);
    method new (line 33) | pub fn new() -> Self {
    method buffer (line 38) | pub fn buffer(&self) -> &cosmic_text::Buffer {
    method downgrade (line 47) | pub fn downgrade(&self) -> Weak {
    method internal (line 56) | fn internal(&self) -> &Arc<Internal> {
    method with_internal_mut (line 62) | fn with_internal_mut<T>(&mut self, f: impl FnOnce(&mut Internal) -> T)...
    type Font (line 85) | type Font = Font;
    method with_text (line 87) | fn with_text(text: &str) -> Self {
    method is_empty (line 110) | fn is_empty(&self) -> bool {
    method line (line 116) | fn line(&self, index: usize) -> Option<editor::Line<'_>> {
    method line_count (line 129) | fn line_count(&self) -> usize {
    method copy (line 133) | fn copy(&self) -> Option<String> {
    method selection (line 137) | fn selection(&self) -> editor::Selection {
    method cursor (line 260) | fn cursor(&self) -> Cursor {
    method perform (line 288) | fn perform(&mut self, action: Action) {
    method move_to (line 462) | fn move_to(&mut self, cursor: Cursor) {
    method bounds (line 483) | fn bounds(&self) -> Size {
    method min_bounds (line 487) | fn min_bounds(&self) -> Size {
    method hint_factor (line 495) | fn hint_factor(&self) -> Option<f32> {
    method update (line 501) | fn update(
    method highlight (line 610) | fn highlight<H: Highlighter>(
  type Internal (line 20) | struct Internal {
    method fmt (line 726) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 691) | fn default() -> Self {
  method eq (line 697) | fn eq(&self, other: &Self) -> bool {
  method default (line 706) | fn default() -> Self {
  type Weak (line 736) | pub struct Weak {
    method upgrade (line 744) | pub fn upgrade(&self) -> Option<Editor> {
  method eq (line 750) | fn eq(&self, other: &Self) -> bool {
  function highlight_line (line 758) | fn highlight_line(
  function visual_lines_offset (line 804) | fn visual_lines_offset(line: usize, buffer: &cosmic_text::Buffer) -> i32 {
  function to_motion (line 819) | fn to_motion(motion: Motion) -> cosmic_text::Motion {
  function buffer_from_editor (line 836) | fn buffer_from_editor<'a, 'b>(editor: &'a impl cosmic_text::Edit<'b>) ->...
  function buffer_mut_from_editor (line 847) | fn buffer_mut_from_editor<'a, 'b>(

FILE: graphics/src/text/paragraph.rs
  type Paragraph (line 13) | pub struct Paragraph(Arc<Internal>);
    method new (line 33) | pub fn new() -> Self {
    method buffer (line 38) | pub fn buffer(&self) -> &cosmic_text::Buffer {
    method downgrade (line 47) | pub fn downgrade(&self) -> Weak {
    method internal (line 58) | fn internal(&self) -> &Arc<Internal> {
    type Font (line 64) | type Font = Font;
    method with_text (line 66) | fn with_text(text: Text<&str>) -> Self {
    method with_spans (line 126) | fn with_spans<Link>(text: Text<&[Span<'_, Link>]>) -> Self {
    method resize (line 208) | fn resize(&mut self, new_bounds: Size) {
    method compare (line 226) | fn compare(&self, text: Text<()>) -> core::text::Difference {
    method hint_factor (line 252) | fn hint_factor(&self) -> Option<f32> {
    method size (line 256) | fn size(&self) -> Pixels {
    method font (line 260) | fn font(&self) -> Font {
    method line_height (line 264) | fn line_height(&self) -> LineHeight {
    method align_x (line 270) | fn align_x(&self) -> Alignment {
    method align_y (line 274) | fn align_y(&self) -> alignment::Vertical {
    method wrapping (line 278) | fn wrapping(&self) -> Wrapping {
    method ellipsis (line 282) | fn ellipsis(&self) -> Ellipsis {
    method shaping (line 286) | fn shaping(&self) -> Shaping {
    method bounds (line 290) | fn bounds(&self) -> Size {
    method min_bounds (line 294) | fn min_bounds(&self) -> Size {
    method hit_test (line 298) | fn hit_test(&self, point: Point) -> Option<Hit> {
    method hit_span (line 307) | fn hit_span(&self, point: Point) -> Option<usize> {
    method span_bounds (line 341) | fn span_bounds(&self, index: usize) -> Vec<Rectangle> {
    method grapheme_position (line 389) | fn grapheme_position(&self, line: usize, index: usize) -> Option<Point> {
    method fmt (line 437) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Internal (line 16) | struct Internal {
  method default (line 431) | fn default() -> Self {
  method eq (line 452) | fn eq(&self, other: &Self) -> bool {
  method default (line 464) | fn default() -> Self {
  type Weak (line 487) | pub struct Weak {
    method upgrade (line 499) | pub fn upgrade(&self) -> Option<Paragraph> {
  method eq (line 505) | fn eq(&self, other: &Self) -> bool {

FILE: graphics/src/viewport.rs
  type Viewport (line 5) | pub struct Viewport {
    method with_physical_size (line 15) | pub fn with_physical_size(size: Size<u32>, scale_factor: f32) -> Viewp...
    method physical_size (line 28) | pub fn physical_size(&self) -> Size<u32> {
    method physical_width (line 33) | pub fn physical_width(&self) -> u32 {
    method physical_height (line 38) | pub fn physical_height(&self) -> u32 {
    method logical_size (line 43) | pub fn logical_size(&self) -> Size<f32> {
    method scale_factor (line 48) | pub fn scale_factor(&self) -> f32 {
    method projection (line 53) | pub fn projection(&self) -> Transformation {

FILE: highlighter/src/lib.rs
  constant LINES_PER_SNAPSHOT (line 20) | const LINES_PER_SNAPSHOT: usize = 50;
  type Highlighter (line 24) | pub struct Highlighter {
    type Settings (line 32) | type Settings = Settings;
    type Highlight (line 33) | type Highlight = Highlight;
    type Iterator (line 35) | type Iterator<'a> = Box<dyn Iterator<Item = (Range<usize>, Self::Highl...
    method new (line 37) | fn new(settings: &Self::Settings) -> Self {
    method update (line 55) | fn update(&mut self, new_settings: &Self::Settings) {
    method change_line (line 66) | fn change_line(&mut self, line: usize) {
    method highlight_line (line 87) | fn highlight_line(&mut self, line: &str) -> Self::Iterator<'_> {
    method current_line (line 103) | fn current_line(&self) -> usize {
  function scope_iterator (line 108) | fn scope_iterator<'a>(
  type Stream (line 138) | pub struct Stream {
    method new (line 148) | pub fn new(settings: &Settings) -> Self {
    method highlight_line (line 168) | pub fn highlight_line(
    method commit (line 180) | pub fn commit(&mut self) {
    method reset (line 185) | pub fn reset(&mut self) {
  type Settings (line 194) | pub struct Settings {
  type Highlight (line 208) | pub struct Highlight(highlighting::StyleModifier);
    method color (line 214) | pub fn color(&self) -> Option<Color> {
    method font (line 223) | pub fn font(&self) -> Option<Font> {
    method to_format (line 254) | pub fn to_format(&self) -> Format<Font> {
  type Theme (line 265) | pub enum Theme {
    constant ALL (line 275) | pub const ALL: &'static [Self] = &[
    method is_dark (line 284) | pub fn is_dark(self) -> bool {
    method key (line 293) | fn key(self) -> &'static str {
    method fmt (line 305) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ScopeRangeIterator (line 316) | struct ScopeRangeIterator {
  type Item (line 324) | type Item = (std::ops::Range<usize>, parsing::ScopeStackOp);
  method next (line 326) | fn next(&mut self) -> Option<Self::Item> {

FILE: program/src/lib.rs
  type Program (line 27) | pub trait Program: Sized {
    method name (line 44) | fn name() -> &'static str;
    method settings (line 46) | fn settings(&self) -> Settings;
    method window (line 48) | fn window(&self) -> Option<window::Settings>;
    method boot (line 50) | fn boot(&self) -> (Self::State, Task<Self::Message>);
    method update (line 52) | fn update(&self, state: &mut Self::State, message: Self::Message) -> T...
    method view (line 54) | fn view<'a>(
    method title (line 60) | fn title(&self, _state: &Self::State, _window: window::Id) -> String {
    method subscription (line 89) | fn subscription(&self, _state: &Self::State) -> Subscription<Self::Mes...
    method theme (line 93) | fn theme(&self, _state: &Self::State, _window: window::Id) -> Option<S...
    method style (line 97) | fn style(&self, _state: &Self::State, theme: &Self::Theme) -> theme::S...
    method scale_factor (line 101) | fn scale_factor(&self, _state: &Self::State, _window: window::Id) -> f...
    method presets (line 105) | fn presets(&self) -> &[Preset<Self::State, Self::Message>] {
  function with_title (line 111) | pub fn with_title<P: Program>(
  function with_subscription (line 184) | pub fn with_subscription<P: Program>(
  function with_theme (line 259) | pub fn with_theme<P: Program>(
  function with_style (line 331) | pub fn with_style<P: Program>(
  function with_scale_factor (line 403) | pub fn with_scale_factor<P: Program>(
  function with_executor (line 478) | pub fn with_executor<P: Program, E: Executor>(
  type Renderer (line 554) | pub trait Renderer: text::Renderer<Font = Font> + compositor::Default + ...
  type Instance (line 562) | pub struct Instance<P: Program> {
  function new (line 569) | pub fn new(program: P) -> (Self, Task<P::Message>) {
  function title (line 576) | pub fn title(&self, window: window::Id) -> String {
  function update (line 581) | pub fn update(&mut self, message: P::Message) -> Task<P::Message> {
  function view (line 586) | pub fn view(&self, window: window::Id) -> Element<'_, P::Message, P::The...
  function subscription (line 591) | pub fn subscription(&self) -> Subscription<P::Message> {
  function theme (line 596) | pub fn theme(&self, window: window::Id) -> Option<P::Theme> {
  function style (line 601) | pub fn style(&self, theme: &P::Theme) -> theme::Style {
  function scale_factor (line 606) | pub fn scale_factor(&self, window: window::Id) -> f32 {

FILE: program/src/message.rs
  type MaybeClone (line 6) | pub trait MaybeClone: Clone {}
  type MaybeClone (line 14) | pub trait MaybeClone {}
  type MaybeDebug (line 22) | pub trait MaybeDebug: std::fmt::Debug {}
  type MaybeDebug (line 30) | pub trait MaybeDebug {}

FILE: program/src/preset.rs
  type Preset (line 7) | pub struct Preset<State, Message> {
  function new (line 14) | pub fn new(
  function name (line 25) | pub fn name(&self) -> &str {
  function boot (line 31) | pub fn boot(&self) -> (State, Task<Message>) {
  function fmt (line 37) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: renderer/src/fallback.rs
  type Renderer (line 19) | pub enum Renderer<A, B> {
  function fill_quad (line 40) | fn fill_quad(&mut self, quad: renderer::Quad, background: impl Into<Back...
  function start_layer (line 44) | fn start_layer(&mut self, bounds: Rectangle) {
  function end_layer (line 48) | fn end_layer(&mut self) {
  function start_transformation (line 52) | fn start_transformation(&mut self, transformation: Transformation) {
  function end_transformation (line 60) | fn end_transformation(&mut self) {
  function allocate_image (line 64) | fn allocate_image(
  function hint (line 72) | fn hint(&mut self, scale_factor: f32) {
  function scale_factor (line 76) | fn scale_factor(&self) -> Option<f32> {
  function tick (line 80) | fn tick(&mut self) {
  function reset (line 84) | fn reset(&mut self, new_bounds: Rectangle) {
  type Font (line 94) | type Font = A::Font;
  type Paragraph (line 95) | type Paragraph = A::Paragraph;
  type Editor (line 96) | type Editor = A::Editor;
  constant ICON_FONT (line 98) | const ICON_FONT: Self::Font = A::ICON_FONT;
  constant CHECKMARK_ICON (line 99) | const CHECKMARK_ICON: char = A::CHECKMARK_ICON;
  constant ARROW_DOWN_ICON (line 100) | const ARROW_DOWN_ICON: char = A::ARROW_DOWN_ICON;
  constant SCROLL_UP_ICON (line 101) | const SCROLL_UP_ICON: char = A::SCROLL_UP_ICON;
  constant SCROLL_DOWN_ICON (line 102) | const SCROLL_DOWN_ICON: char = A::SCROLL_DOWN_ICON;
  constant SCROLL_LEFT_ICON (line 103) | const SCROLL_LEFT_ICON: char = A::SCROLL_LEFT_ICON;
  constant SCROLL_RIGHT_ICON (line 104) | const SCROLL_RIGHT_ICON: char = A::SCROLL_RIGHT_ICON;
  constant ICED_LOGO (line 105) | const ICED_LOGO: char = A::ICED_LOGO;
  function default_font (line 107) | fn default_font(&self) -> Self::Font {
  function default_size (line 111) | fn default_size(&self) -> core::Pixels {
  function fill_paragraph (line 115) | fn fill_paragraph(
  function fill_editor (line 129) | fn fill_editor(
  function fill_text (line 143) | fn fill_text(
  function fill_raw (line 163) | fn fill_raw(&mut self, raw: text::Raw) {
  type Handle (line 173) | type Handle = A::Handle;
  function load_image (line 175) | fn load_image(&self, handle: &Self::Handle) -> Result<image::Allocation,...
  function measure_image (line 179) | fn measure_image(&self, handle: &Self::Handle) -> Option<Size<u32>> {
  function draw_image (line 183) | fn draw_image(&mut self, image: Image<A::Handle>, bounds: Rectangle, cli...
  function measure_svg (line 197) | fn measure_svg(&self, handle: &svg::Handle) -> Size<u32> {
  function draw_svg (line 201) | fn draw_svg(&mut self, svg: Svg, bounds: Rectangle, clip_bounds: Rectang...
  function draw_mesh (line 211) | fn draw_mesh(&mut self, mesh: graphics::Mesh) {
  function draw_mesh_cache (line 215) | fn draw_mesh_cache(&mut self, cache: mesh::Cache) {
  type Compositor (line 224) | pub enum Compositor<A, B>
  type Surface (line 239) | pub enum Surface<A, B> {
  type Renderer (line 251) | type Renderer = Renderer<A::Renderer, B::Renderer>;
  type Surface (line 252) | type Surface = Surface<A::Surface, B::Surface>;
  function with_backend (line 254) | async fn with_backend(
  function create_renderer (line 319) | fn create_renderer(&self, settings: renderer::Settings) -> Self::Renderer {
  function create_surface (line 328) | fn create_surface<W: compositor::Window + Clone>(
  function configure_surface (line 344) | fn configure_surface(&mut self, surface: &mut Self::Surface, width: u32,...
  function load_font (line 356) | fn load_font(&mut self, font: Cow<'static, [u8]>) -> Result<(), font::Er...
  function list_fonts (line 360) | fn list_fonts(&mut self) -> Result<Vec<font::Family>, font::Error> {
  function information (line 364) | fn information(&self) -> compositor::Information {
  function present (line 368) | fn present(
  function screenshot (line 401) | fn screenshot(
  function draw_primitive (line 425) | fn draw_primitive(&mut self, bounds: Rectangle, primitive: impl iced_wgp...
  type Geometry (line 449) | type Geometry = Geometry<A::Geometry, B::Geometry>;
  type Frame (line 450) | type Frame = Frame<A::Frame, B::Frame>;
  function new_frame (line 452) | fn new_frame(&self, bounds: Rectangle) -> Self::Frame {
  function draw_geometry (line 459) | fn draw_geometry(&mut self, geometry: Self::Geometry) {
  type Geometry (line 473) | pub enum Geometry<A, B> {
  type Cache (line 483) | type Cache = Geometry<A::Cache, B::Cache>;
  method load (line 485) | fn load(cache: &Self::Cache) -> Self {
  method cache (line 492) | fn cache(self, group: cache::Group, previous: Option<Self::Cache>) -> Se...
  type Frame (line 510) | pub enum Frame<A, B> {
  type Geometry (line 520) | type Geometry = Geometry<A::Geometry, B::Geometry>;
  function width (line 522) | fn width(&self) -> f32 {
  function height (line 526) | fn height(&self) -> f32 {
  function size (line 530) | fn size(&self) -> Size {
  function center (line 534) | fn center(&self) -> Point {
  function fill (line 538) | fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
  function fill_rectangle (line 542) | fn fill_rectangle(&mut self, top_left: Point, size: Size, fill: impl Int...
  function stroke (line 546) | fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
  function stroke_rectangle (line 550) | fn stroke_rectangle<'a>(
  function stroke_text (line 559) | fn stroke_text<'a>(&mut self, text: impl Into<Text>, stroke: impl Into<S...
  function fill_text (line 563) | fn fill_text(&mut self, text: impl Into<Text>) {
  function draw_image (line 567) | fn draw_image(&mut self, bounds: Rectangle, image: impl Into<Image>) {
  function draw_svg (line 571) | fn draw_svg(&mut self, bounds: Rectangle, svg: impl Into<Svg>) {
  function push_transform (line 575) | fn push_transform(&mut self) {
  function pop_transform (line 579) | fn pop_transform(&mut self) {
  function draft (line 583) | fn draft(&mut self, bounds: Rectangle) -> Self {
  function paste (line 590) | fn paste(&mut self, frame: Self) {
  function translate (line 602) | fn translate(&mut self, translation: Vector) {
  function rotate (line 606) | fn rotate(&mut self, angle: impl Into<Radians>) {
  function scale (line 610) | fn scale(&mut self, scale: impl Into<f32>) {
  function scale_nonuniform (line 614) | fn scale_nonuniform(&mut self, scale: impl Into<Vector>) {
  function into_geometry (line 618) | fn into_geometry(self) -> Self::Geometry {
  function new (line 632) | async fn new(settings: renderer::Settings, backend: Option<&str>) -> Opt...
  function name (line 640) | fn name(&self) -> String {
  function screenshot (line 644) | fn screenshot(
  type Compositor (line 666) | type Compositor = Compositor<A::Compositor, B::Compositor>;

FILE: renderer/src/lib.rs
  type Renderer (line 18) | pub type Renderer = renderer::Renderer;
  type Compositor (line 23) | pub type Compositor = renderer::Compositor;
  type Renderer (line 27) | pub type Renderer = crate::fallback::Renderer<iced_wgpu::Renderer, iced_...
  type Compositor (line 29) | pub type Compositor = crate::fallback::Compositor<
  type Renderer (line 37) | pub type Renderer = iced_wgpu::Renderer;
  type Compositor (line 38) | pub type Compositor = iced_wgpu::window::Compositor;
  type Renderer (line 43) | pub type Renderer = iced_tiny_skia::Renderer;
  type Compositor (line 44) | pub type Compositor = iced_tiny_skia::window::Compositor;
  type Renderer (line 56) | pub type Renderer = ();
  type Compositor (line 57) | pub type Compositor = ();

FILE: runtime/src/clipboard.rs
  type Action (line 13) | pub enum Action {
  function read (line 33) | pub fn read(kind: Kind) -> Task<Result<Arc<Content>, Error>> {
  function read_text (line 39) | pub fn read_text() -> Task<Result<Arc<String>, Error>> {
  function read_html (line 56) | pub fn read_html() -> Task<Result<Arc<String>, Error>> {
  function read_files (line 73) | pub fn read_files() -> Task<Result<Arc<[PathBuf]>, Error>> {
  function read_image (line 91) | pub fn read_image() -> Task<Result<crate::core::clipboard::Image, Error>> {
  function write (line 108) | pub fn write(content: impl Into<Content>) -> Task<Result<(), Error>> {

FILE: runtime/src/font.rs
  type Action (line 11) | pub enum Action {
    method fmt (line 36) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function load (line 50) | pub fn load(bytes: impl Into<Cow<'static, [u8]>>) -> Task<Result<(), Err...
  function list (line 60) | pub fn list() -> Task<Result<Vec<Family>, Error>> {
  function set_defaults (line 65) | pub fn set_defaults<Message>(font: Font, text_size: impl Into<Pixels>) -...

FILE: runtime/src/image.rs
  type Action (line 10) | pub enum Action {
  function allocate (line 20) | pub fn allocate(handle: impl Into<Handle>) -> Task<Result<Allocation, Er...

FILE: runtime/src/lib.rs
  type Action (line 34) | pub enum Action<T> {
  function widget (line 79) | pub fn widget(operation: impl core::widget::Operation + 'static) -> Self {
  function output (line 83) | fn output<O>(self) -> Result<T, Action<O>> {
  function fmt (line 104) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function exit (line 134) | pub fn exit<T>() -> Task<T> {

FILE: runtime/src/system.rs
  type Action (line 9) | pub enum Action {
  type Information (line 22) | pub struct Information {
  function information (line 51) | pub fn information() -> Task<Information> {
  function theme (line 56) | pub fn theme() -> Task<theme::Mode> {
  function theme_changes (line 61) | pub fn theme_changes() -> Subscription<theme::Mode> {

FILE: runtime/src/task.rs
  type Task (line 24) | pub struct Task<T> {
  function none (line 31) | pub fn none() -> Self {
  function done (line 39) | pub fn done(value: T) -> Self
  function perform (line 53) | pub fn perform<A>(
  function run (line 66) | pub fn run<A>(
  function sip (line 79) | pub fn sip<S>(
  function batch (line 95) | pub fn batch(tasks: impl IntoIterator<Item = Self>) -> Self
  function map (line 117) | pub fn map<O>(self, mut f: impl FnMut(T) -> O + MaybeSend + 'static) -> ...
  function then (line 130) | pub fn then<O>(self, mut f: impl FnMut(T) -> Task<O> + MaybeSend + 'stat...
  function chain (line 152) | pub fn chain(self, task: Self) -> Self
  function collect (line 172) | pub fn collect(self) -> Task<Vec<T>>
  function discard (line 209) | pub fn discard<O>(self) -> Task<O>
  function abortable (line 218) | pub fn abortable(self) -> (Self, Handle)
  function future (line 245) | pub fn future(future: impl Future<Output = T> + MaybeSend + 'static) -> ...
  function stream (line 254) | pub fn stream(stream: impl Stream<Item = T> + MaybeSend + 'static) -> Self
  function units (line 269) | pub fn units(&self) -> usize {
  function fmt (line 275) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Handle (line 284) | pub struct Handle {
    method abort (line 305) | pub fn abort(&self) {
    method abort_on_drop (line 317) | pub fn abort_on_drop(self) -> Self {
    method is_aborted (line 327) | pub fn is_aborted(&self) -> bool {
  type InternalHandle (line 289) | enum InternalHandle {
    method as_ref (line 295) | pub fn as_ref(&self) -> &stream::AbortHandle {
  method drop (line 333) | fn drop(&mut self) {
  function and_then (line 348) | pub fn and_then<A>(self, f: impl Fn(T) -> Task<A> + MaybeSend + 'static)...
  function and_then (line 361) | pub fn and_then<A>(
  function map_err (line 375) | pub fn map_err<E2>(self, f: impl Fn(E) -> E2 + MaybeSend + 'static) -> T...
  method default (line 386) | fn default() -> Self {
  function from (line 392) | fn from(_value: ()) -> Self {
  function widget (line 399) | pub fn widget<T>(operation: impl widget::Operation<T> + 'static) -> Task<T>
  function oneshot (line 414) | pub fn oneshot<T>(f: impl FnOnce(oneshot::Sender<T>) -> Action<T>) -> Ta...
  function channel (line 436) | pub fn channel<T>(f: impl FnOnce(mpsc::Sender<T>) -> Action<T>) -> Task<T>
  function effect (line 454) | pub fn effect<T>(action: impl Into<Action<Infallible>>) -> Task<T> {
  function into_stream (line 466) | pub fn into_stream<T>(task: Task<T>) -> Option<BoxStream<Action<T>>> {
  function blocking (line 474) | pub fn blocking<T>(f: impl FnOnce(mpsc::Sender<T>) + Send + 'static) -> ...
  function try_blocking (line 492) | pub fn try_blocking<T, E>(
  function yield_now (line 514) | async fn yield_now() {

FILE: runtime/src/user_interface.rs
  type UserInterface (line 23) | pub struct UserInterface<'a, Message, Theme, Renderer> {
  type Overlay (line 31) | struct Overlay {
  function build (line 91) | pub fn build<E: Into<Element<'a, Message, Theme, Renderer>>>(
  function update (line 179) | pub fn update(
  function draw (line 463) | pub fn draw(
  function operate (line 520) | pub fn operate(&mut self, renderer: &Renderer, operation: &mut dyn widge...
  function relayout (line 559) | pub fn relayout(self, bounds: Size, renderer: &mut Renderer) -> Self {
  function into_cache (line 565) | pub fn into_cache(self) -> Cache {
  type Cache (line 572) | pub struct Cache {
    method new (line 581) | pub fn new() -> Cache {
  method default (line 589) | fn default() -> Cache {
  type State (line 596) | pub enum State {
    method has_layout_changed (line 618) | pub fn has_layout_changed(&self) -> bool {

FILE: runtime/src/widget/operation.rs
  function snap_to (line 10) | pub fn snap_to<T>(id: impl Into<Id>, offset: impl Into<RelativeOffset<Op...
  function snap_to_end (line 18) | pub fn snap_to_end<T>(id: impl Into<Id>) -> Task<T> {
  function scroll_to (line 26) | pub fn scroll_to<T>(id: impl Into<Id>, offset: impl Into<AbsoluteOffset<...
  function scroll_by (line 34) | pub fn scroll_by<T>(id: impl Into<Id>, offset: AbsoluteOffset) -> Task<T> {
  function focus_previous (line 42) | pub fn focus_previous<T>() -> Task<T> {
  function focus_next (line 47) | pub fn focus_next<T>() -> Task<T> {
  function is_focused (line 52) | pub fn is_focused(id: impl Into<Id>) -> Task<bool> {
  function focus (line 57) | pub fn focus<T>(id: impl Into<Id>) -> Task<T> {
  function move_cursor_to_end (line 62) | pub fn move_cursor_to_end<T>(id: impl Into<Id>) -> Task<T> {
  function move_cursor_to_front (line 69) | pub fn move_cursor_to_front<T>(id: impl Into<Id>) -> Task<T> {
  function move_cursor_to (line 76) | pub fn move_cursor_to<T>(id: impl Into<Id>, position: usize) -> Task<T> {
  function select_all (line 84) | pub fn select_all<T>(id: impl Into<Id>) -> Task<T> {
  function select_range (line 89) | pub fn select_range<T>(id: impl Into<Id>, start: usize, end: usize) -> T...

FILE: runtime/src/widget/selector.rs
  function find (line 8) | pub fn find<S>(selector: S) -> Task<Option<S::Output>>
  function find_all (line 17) | pub fn find_all<S>(selector: S) -> Task<Vec<S::Output>>

FILE: runtime/src/window.rs
  type Action (line 17) | pub enum Action {
  type Window (line 195) | pub trait Window: HasWindowHandle + HasDisplayHandle {}
  function frames (line 207) | pub fn frames() -> Subscription<Instant> {
  function events (line 215) | pub fn events() -> Subscription<(Id, Event)> {
  function open_events (line 226) | pub fn open_events() -> Subscription<Id> {
  function close_events (line 237) | pub fn close_events() -> Subscription<Id> {
  function resize_events (line 248) | pub fn resize_events() -> Subscription<(Id, Size)> {
  function close_requests (line 259) | pub fn close_requests() -> Subscription<Id> {
  function open (line 271) | pub fn open(settings: Settings) -> (Id, Task<Id>) {
  function close (line 281) | pub fn close<T>(id: Id) -> Task<T> {
  function oldest (line 286) | pub fn oldest() -> Task<Option<Id>> {
  function latest (line 291) | pub fn latest() -> Task<Option<Id>> {
  function drag (line 296) | pub fn drag<T>(id: Id) -> Task<T> {
  function drag_resize (line 301) | pub fn drag_resize<T>(id: Id, direction: Direction) -> Task<T> {
  function resize (line 306) | pub fn resize<T>(id: Id, new_size: Size) -> Task<T> {
  function set_resizable (line 311) | pub fn set_resizable<T>(id: Id, resizable: bool) -> Task<T> {
  function set_max_size (line 316) | pub fn set_max_size<T>(id: Id, size: Option<Size>) -> Task<T> {
  function set_min_size (line 321) | pub fn set_min_size<T>(id: Id, size: Option<Size>) -> Task<T> {
  function set_resize_increments (line 328) | pub fn set_resize_increments<T>(id: Id, increments: Option<Size>) -> Tas...
  function size (line 335) | pub fn size(id: Id) -> Task<Size> {
  function is_maximized (line 340) | pub fn is_maximized(id: Id) -> Task<bool> {
  function maximize (line 345) | pub fn maximize<T>(id: Id, maximized: bool) -> Task<T> {
  function is_minimized (line 350) | pub fn is_minimized(id: Id) -> Task<Option<bool>> {
  function minimize (line 355) | pub fn minimize<T>(id: Id, minimized: bool) -> Task<T> {
  function position (line 360) | pub fn position(id: Id) -> Task<Option<Point>> {
  function scale_factor (line 365) | pub fn scale_factor(id: Id) -> Task<f32> {
  function move_to (line 370) | pub fn move_to<T>(id: Id, position: Point) -> Task<T> {
  function mode (line 375) | pub fn mode(id: Id) -> Task<Mode> {
  function set_mode (line 380) | pub fn set_mode<T>(id: Id, mode: Mode) -> Task<T> {
  function toggle_maximize (line 385) | pub fn toggle_maximize<T>(id: Id) -> Task<T> {
  function toggle_decorations (line 390) | pub fn toggle_decorations<T>(id: Id) -> Task<T> {
  function request_user_attention (line 400) | pub fn request_user_attention<T>(id: Id, user_attention: Option<UserAtte...
  function gain_focus (line 413) | pub fn gain_focus<T>(id: Id) -> Task<T> {
  function set_level (line 418) | pub fn set_level<T>(id: Id, level: Level) -> Task<T> {
  function show_system_menu (line 425) | pub fn show_system_menu<T>(id: Id) -> Task<T> {
  function raw_id (line 431) | pub fn raw_id<Message>(id: Id) -> Task<u64> {
  function set_icon (line 436) | pub fn set_icon<T>(id: Id, icon: Icon) -> Task<T> {
  function run (line 443) | pub fn run<T>(id: Id, f: impl FnOnce(&dyn Window) -> T + Send + 'static)...
  function screenshot (line 458) | pub fn screenshot(id: Id) -> Task<Screenshot> {
  function enable_mouse_passthrough (line 466) | pub fn enable_mouse_passthrough<Message>(id: Id) -> Task<Message> {
  function disable_mouse_passthrough (line 474) | pub fn disable_mouse_passthrough<Message>(id: Id) -> Task<Message> {
  function monitor_size (line 479) | pub fn monitor_size(id: Id) -> Task<Option<Size>> {
  function allow_automatic_tabbing (line 486) | pub fn allow_automatic_tabbing<T>(enabled: bool) -> Task<T> {

FILE: selector/src/find.rs
  type Find (line 11) | pub type Find<S> = Finder<One<S>>;
  type FindAll (line 15) | pub type FindAll<S> = Finder<All<S>>;
  type One (line 18) | pub struct One<S>
  function new (line 30) | pub fn new(selector: S) -> Self {
  type All (line 61) | pub struct All<S>
  function new (line 73) | pub fn new(selector: S) -> Self {
  type Strategy (line 103) | pub trait Strategy {
    type Output (line 43) | type Output = Option<S::Output>;
    method feed (line 45) | fn feed(&mut self, target: Candidate<'_>) {
    method is_done (line 51) | fn is_done(&self) -> bool {
    method finish (line 55) | fn finish(&self) -> Self::Output {
    type Output (line 86) | type Output = Vec<S::Output>;
    method feed (line 88) | fn feed(&mut self, target: Candidate<'_>) {
    method is_done (line 94) | fn is_done(&self) -> bool {
    method finish (line 98) | fn finish(&self) -> Self::Output {
    method feed (line 106) | fn feed(&mut self, target: Candidate<'_>);
    method is_done (line 108) | fn is_done(&self) -> bool;
    method finish (line 110) | fn finish(&self) -> Self::Output;
  type Finder (line 114) | pub struct Finder<S> {
  function new (line 122) | pub fn new(strategy: S) -> Self {
  function traverse (line 137) | fn traverse(&mut self, operate: &mut dyn FnMut(&mut dyn Operation<S::Out...
  function container (line 151) | fn container(&mut self, id: Option<&Id>, bounds: Rectangle) {
  function focusable (line 163) | fn focusable(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut ...
  function scrollable (line 176) | fn scrollable(
  function text_input (line 203) | fn text_input(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut...
  function text (line 216) | fn text(&mut self, id: Option<&Id>, bounds: Rectangle, text: &str) {
  function custom (line 229) | fn custom(&mut self, id: Option<&Id>, bounds: Rectangle, state: &mut dyn...
  function finish (line 242) | fn finish(&self) -> Outcome<S::Output> {

FILE: selector/src/lib.rs
  type Selector (line 14) | pub trait Selector {
    method select (line 29) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output>;
    method description (line 32) | fn description(&self) -> String;
    method find (line 36) | fn find(self) -> Find<Self>
    method find_all (line 45) | fn find_all(self) -> FindAll<Self>
    type Output (line 54) | type Output = target::Text;
    method select (line 56) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
    method description (line 82) | fn description(&self) -> String {
    type Output (line 88) | type Output = target::Text;
    method select (line 90) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
    method description (line 94) | fn description(&self) -> String {
    type Output (line 100) | type Output = Target;
    method select (line 102) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
    method description (line 110) | fn description(&self) -> String {
    type Output (line 116) | type Output = Target;
    method select (line 118) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
    method description (line 125) | fn description(&self) -> String {
    type Output (line 134) | type Output = T;
    method select (line 136) | fn select(&mut self, candidate: Candidate<'_>) -> Option<Self::Output> {
    method description (line 140) | fn description(&self) -> String {
  function id (line 146) | pub fn id(id: impl Into<widget::Id>) -> impl Selector<Output = Target> {
  function is_focused (line 151) | pub fn is_focused() -> impl Selector<Output = Target> {

FILE: selector/src/target.rs
  type Target (line 10) | pub enum Target {
    method bounds (line 49) | pub fn bounds(&self) -> Rectangle {
    method visible_bounds (line 61) | pub fn visible_bounds(&self) -> Option<Rectangle> {
    method from (line 74) | fn from(candidate: Candidate<'_>) -> Self {
  type Candidate (line 160) | pub enum Candidate<'a> {
  function id (line 202) | pub fn id(&self) -> Option<&'a Id> {
  function bounds (line 214) | pub fn bounds(&self) -> Rectangle {
  function visible_bounds (line 226) | pub fn visible_bounds(&self) -> Option<Rectangle> {
  type Bounded (line 242) | pub trait Bounded: std::fmt::Debug {
    method bounds (line 146) | fn bounds(&self) -> Rectangle {
    method visible_bounds (line 150) | fn visible_bounds(&self) -> Option<Rectangle> {
    method bounds (line 244) | fn bounds(&self) -> Rectangle;
    method visible_bounds (line 247) | fn visible_bounds(&self) -> Option<Rectangle>;
    method bounds (line 285) | fn bounds(&self) -> Rectangle {
    method visible_bounds (line 289) | fn visible_bounds(&self) -> Option<Rectangle> {
  type Text (line 253) | pub enum Text {
    method bounds (line 268) | pub fn bounds(&self) -> Rectangle {
    method visible_bounds (line 275) | pub fn visible_bounds(&self) -> Option<Rectangle> {

FILE: src/application.rs
  function application (line 78) | pub fn application<State, Message, Theme, Renderer>(
  type Application (line 172) | pub struct Application<P: Program> {
  function run (line 181) | pub fn run(self) -> Result
  function settings (line 213) | pub fn settings(self, settings: Settings) -> Self {
  function antialiasing (line 218) | pub fn antialiasing(self, antialiasing: bool) -> Self {
  function default_font (line 229) | pub fn default_font(self, default_font: Font) -> Self {
  function font (line 240) | pub fn font(mut self, font: impl Into<Cow<'static, [u8]>>) -> Self {
  function window (line 248) | pub fn window(self, window: window::Settings) -> Self {
  function centered (line 253) | pub fn centered(self) -> Self {
  function exit_on_close_request (line 264) | pub fn exit_on_close_request(self, exit_on_close_request: bool) -> Self {
  function window_size (line 275) | pub fn window_size(self, size: impl Into<Size>) -> Self {
  function transparent (line 286) | pub fn transparent(self, transparent: bool) -> Self {
  function resizable (line 297) | pub fn resizable(self, resizable: bool) -> Self {
  function decorations (line 308) | pub fn decorations(self, decorations: bool) -> Self {
  function position (line 319) | pub fn position(self, position: window::Position) -> Self {
  function level (line 330) | pub fn level(self, level: window::Level) -> Self {
  function title (line 341) | pub fn title(
  function subscription (line 354) | pub fn subscription(
  function theme (line 367) | pub fn theme(
  function style (line 380) | pub fn style(
  function scale_factor (line 393) | pub fn scale_factor(
  function executor (line 406) | pub fn executor<E>(
  function presets (line 425) | pub fn presets(self, presets: impl IntoIterator<Item = Preset<P::State, ...
  type State (line 434) | type State = P::State;
  type Message (line 435) | type Message = P::Message;
  type Theme (line 436) | type Theme = P::Theme;
  type Renderer (line 437) | type Renderer = P::Renderer;
  type Executor (line 438) | type Executor = P::Executor;
  method name (line 440) | fn name() -> &'static str {
  method settings (line 444) | fn settings(&self) -> Settings {
  method window (line 448) | fn window(&self) -> Option<window::Settings> {
  method boot (line 452) | fn boot(&self) -> (Self::State, Task<Self::Message>) {
  method update (line 456) | fn update(&self, state: &mut Self::State, message: Self::Message) -> Tas...
  method view (line 460) | fn view<'a>(
  method title (line 468) | fn title(&self, state: &Self::State, window: window::Id) -> String {
  method subscription (line 472) | fn subscription(&self, state: &Self::State) -> Subscription<Self::Messag...
  method theme (line 476) | fn theme(&self, state: &Self::State, window: iced_core::window::Id) -> O...
  method style (line 480) | fn style(&self, state: &Self::State, theme: &Self::Theme) -> theme::Style {
  method scale_factor (line 484) | fn scale_factor(&self, state: &Self::State, window: window::Id) -> f32 {
  method presets (line 488) | fn presets(&self) -> &[Preset<Self::State, Self::Message>] {
  type BootFn (line 501) | pub trait BootFn<State, Message> {
    method boot (line 503) | fn boot(&self) -> (State, Task<Message>);
  method boot (line 511) | fn boot(&self) -> (State, Task<Message>) {
  type IntoBoot (line 517) | pub trait IntoBoot<State, Message> {
    method into_boot (line 519) | fn into_boot(self) -> (State, Task<Message>);
  method into_boot (line 523) | fn into_boot(self) -> (State, Task<Message>) {
  function into_boot (line 529) | fn into_boot(self) -> (State, Task<Message>) {
  type TitleFn (line 540) | pub trait TitleFn<State> {
    method title (line 542) | fn title(&self, state: &State) -> String;
  function title (line 546) | fn title(&self, _state: &State) -> String {
  method title (line 555) | fn title(&self, state: &State) -> String {
  type UpdateFn (line 564) | pub trait UpdateFn<State, Message> {
    method update (line 566) | fn update(&self, state: &mut State, message: Message) -> Task<Message>;
  function update (line 570) | fn update(&self, _state: &mut State, _message: Never) -> Task<Never> {
  method update (line 580) | fn update(&self, state: &mut State, message: Message) -> Task<Message> {
  type ViewFn (line 589) | pub trait ViewFn<'a, State, Message, Theme, Renderer> {
    method view (line 591) | fn view(&self, state: &'a State) -> Element<'a, Message, Theme, Render...
  method view (line 601) | fn view(&self, state: &'a State) -> Element<'a, Message, Theme, Renderer> {
  type ThemeFn (line 614) | pub trait ThemeFn<State, Theme> {
    method theme (line 619) | fn theme(&self, state: &State) -> Option<Theme>;
  method theme (line 623) | fn theme(&self, _state: &State) -> Option<Theme> {
  method theme (line 633) | fn theme(&self, state: &State) -> Option<Theme> {

FILE: src/application/timed.rs
  function timed (line 22) | pub fn timed<State, Message, Theme, Renderer>(
  type UpdateFn (line 135) | pub trait UpdateFn<State, Message> {
    method update (line 137) | fn update(&self, state: &mut State, message: Message, now: Instant)
  function update (line 142) | fn update(
  method update (line 156) | fn update(

FILE: src/daemon.rs
  function daemon (line 24) | pub fn daemon<State, Message, Theme, Renderer>(
  type Daemon (line 117) | pub struct Daemon<P: Program> {
  function run (line 125) | pub fn run(self) -> Result
  function settings (line 150) | pub fn settings(self, settings: Settings) -> Self {
  function antialiasing (line 155) | pub fn antialiasing(self, antialiasing: bool) -> Self {
  function default_font (line 166) | pub fn default_font(self, default_font: Font) -> Self {
  function font (line 177) | pub fn font(mut self, font: impl Into<Cow<'static, [u8]>>) -> Self {
  function title (line 183) | pub fn title(
  function subscription (line 195) | pub fn subscription(
  function theme (line 207) | pub fn theme(
  function style (line 219) | pub fn style(
  function scale_factor (line 231) | pub fn scale_factor(
  function executor (line 243) | pub fn executor<E>(
  function presets (line 261) | pub fn presets(self, presets: impl IntoIterator<Item = Preset<P::State, ...
  type State (line 270) | type State = P::State;
  type Message (line 271) | type Message = P::Message;
  type Theme (line 272) | type Theme = P::Theme;
  type Renderer (line 273) | type Renderer = P::Renderer;
  type Executor (line 274) | type Executor = P::Executor;
  method name (line 276) | fn name() -> &'static str {
  method settings (line 280) | fn settings(&self) -> Settings {
  method window (line 284) | fn window(&self) -> Option<window::Settings> {
  method boot (line 288) | fn boot(&self) -> (Self::State, Task<Self::Message>) {
  method update (line 292) | fn update(&self, state: &mut Self::State, message: Self::Message) -> Tas...
  method view (line 296) | fn view<'a>(
  method title (line 304) | fn title(&self, state: &Self::State, window: window::Id) -> String {
  method subscription (line 308) | fn subscription(&self, state: &Self::State) -> Subscription<Self::Messag...
  method theme (line 312) | fn theme(&self, state: &Self::State, window: iced_core::window::Id) -> O...
  method style (line 316) | fn style(&self, state: &Self::State, theme: &Self::Theme) -> theme::Style {
  method scale_factor (line 320) | fn scale_factor(&self, state: &Self::State, window: window::Id) -> f32 {
  method presets (line 324) | fn presets(&self) -> &[Preset<Self::State, Self::Message>] {
  type TitleFn (line 335) | pub trait TitleFn<State> {
    method title (line 337) | fn title(&self, state: &State, window: window::Id) -> String;
  function title (line 341) | fn title(&self, _state: &State, _window: window::Id) -> String {
  method title (line 350) | fn title(&self, state: &State, window: window::Id) -> String {
  type ViewFn (line 359) | pub trait ViewFn<'a, State, Message, Theme, Renderer> {
    method view (line 361) | fn view(&self, state: &'a State, window: window::Id) -> Element<'a, Me...
  method view (line 371) | fn view(&self, state: &'a State, window: window::Id) -> Element<'a, Mess...
  type ThemeFn (line 384) | pub trait ThemeFn<State, Theme> {
    method theme (line 389) | fn theme(&self, state: &State, window: window::Id) -> Option<Theme>;
  method theme (line 393) | fn theme(&self, _state: &State, _window: window::Id) -> Option<Theme> {
  method theme (line 403) | fn theme(&self, state: &State, window: window::Id) -> Option<Theme> {

FILE: src/error.rs
  type Error (line 7) | pub enum Error {
    method from (line 22) | fn from(error: shell::Error) -> Error {
  function assert_send_sync (line 38) | fn assert_send_sync() {

FILE: src/lib.rs
  type Element (line 618) | pub type Element<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  type Element (line 667) | pub type Element<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  type Result (line 671) | pub type Result = std::result::Result<(), Error>;
  function run (line 704) | pub fn run<State, Message, Theme, Renderer>(

FILE: src/time.rs
  function now (line 21) | pub fn now() -> Task<Instant> {

FILE: src/window/icon.rs
  function from_file (line 15) | pub fn from_file<P: AsRef<Path>>(icon_path: P) -> Result<Icon, Error> {
  function from_file_data (line 26) | pub fn from_file_data(
  type Error (line 51) | pub enum Error {

FILE: test/src/emulator.rs
  type Emulator (line 34) | pub struct Emulator<P: Program> {
  type Event (line 47) | pub enum Event<P: Program> {
  type Action (line 57) | pub struct Action<P: Program>(Action_<P>);
  type Action_ (line 59) | enum Action_<P: Program> {
  function new (line 70) | pub fn new(sender: mpsc::Sender<Event<P>>, program: &P, mode: Mode, size...
  function with_preset (line 78) | pub fn with_preset(
  function update (line 129) | pub fn update(&mut self, program: &P, message: P::Message) {
  function perform (line 156) | pub fn perform(&mut self, program: &P, action: Action<P>) {
  function run (line 281) | pub fn run(&mut self, program: &P, instruction: &Instruction) {
  function wait_for (line 383) | fn wait_for(&mut self, task: Task<P::Message>) {
  function resubscribe (line 426) | fn resubscribe(&mut self, program: &P) {
  function view (line 436) | pub fn view(&self, program: &P) -> Element<'_, P::Message, P::Theme, P::...
  function theme (line 441) | pub fn theme(&self, program: &P) -> Option<P::Theme> {
  function screenshot (line 446) | pub fn screenshot(
  function into_state (line 499) | pub fn into_state(self) -> (P::State, core::window::Id) {
  type Mode (line 509) | pub enum Mode {
    constant ALL (line 524) | pub const ALL: &[Self] = &[Self::Zen, Self::Patient, Self::Immediate];
    method fmt (line 528) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: test/src/error.rs
  type Error (line 10) | pub enum Error {
    method from (line 59) | fn from(error: io::Error) -> Self {
    method from (line 65) | fn from(error: png::DecodingError) -> Self {
    method from (line 71) | fn from(error: png::EncodingError) -> Self {

FILE: test/src/ice.rs
  type Ice (line 19) | pub struct Ice {
    method parse (line 57) | pub fn parse(content: &str) -> Result<Self, ParseError> {
    method fmt (line 150) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ParseError (line 177) | pub enum ParseError {

FILE: test/src/instruction.rs
  type Instruction (line 13) | pub enum Instruction {
    method parse (line 22) | pub fn parse(line: &str) -> Result<Self, ParseError> {
    method fmt (line 28) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Interaction (line 38) | pub enum Interaction {
    method from_event (line 49) | pub fn from_event(event: &Event) -> Option<Self> {
    method merge (line 107) | pub fn merge(self, next: Self) -> (Self, Option<Self>) {
    method events (line 205) | pub fn events(&self, find_target: impl FnOnce(&Target) -> Option<Point...
    method fmt (line 269) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Mouse (line 279) | pub enum Mouse {
    method fmt (line 306) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 326) | pub enum Target {
    method fmt (line 336) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Keyboard (line 347) | pub enum Keyboard {
    method fmt (line 359) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Key (line 382) | pub enum Key {
  function from (line 390) | fn from(key: Key) -> Self {
  function button_at (line 403) | pub fn button_at(button: mouse::Button, at: Option<&Target>) -> String {
  function button (line 417) | pub fn button(button: mouse::Button) -> &'static str {
  function point (line 428) | pub fn point(point: Point) -> String {
  function key (line 432) | pub fn key(key: Key) -> &'static str {
  function string (line 441) | pub fn string(text: &str) -> String {
  function id (line 445) | pub fn id(id: &str) -> String {
  type Expectation (line 455) | pub enum Expectation {
    method fmt (line 461) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Error (line 489) | pub struct Error(nom::error::Error<String>);
  function run (line 491) | pub fn run(input: &str) -> Result<Instruction, Error> {
  function instruction (line 498) | fn instruction(input: &str) -> IResult<&str, Instruction> {
  function interaction (line 506) | fn interaction(input: &str) -> IResult<&str, Interaction> {
  function mouse (line 514) | fn mouse(input: &str) -> IResult<&str, Mouse> {
  function mouse_click (line 520) | fn mouse_click(input: &str) -> IResult<&str, Mouse> {
  function mouse_press (line 527) | fn mouse_press(input: &str) -> IResult<&str, Mouse> {
  function mouse_release (line 534) | fn mouse_release(input: &str) -> IResult<&str, Mouse> {
  function mouse_button_at (line 541) | fn mouse_button_at(input: &str) -> IResult<&str, (mouse::Button, Option<...
  function target (line 548) | fn target(input: &str) -> IResult<&str, Target> {
  function mouse_button (line 557) | fn mouse_button(input: &str) -> IResult<&str, mouse::Button> {
  function keyboard (line 565) | fn keyboard(input: &str) -> IResult<&str, Keyboard> {
  function expectation (line 573) | fn expectation(input: &str) -> IResult<&str, Expectation> {
  function key (line 580) | fn key(input: &str) -> IResult<&str, Key> {
  function id (line 590) | fn id(input: &str) -> IResult<&str, &str> {
  function point (line 598) | fn point(input: &str) -> IResult<&str, Point> {
  function whitespace (line 612) | pub fn whitespace<'a, O, E: ParseError<&'a str>, F>(
  function string (line 643) | fn string(input: &str) -> IResult<&str, String> {

FILE: test/src/lib.rs
  function run (line 123) | pub fn run<P: program::Program + 'static>(
  function screenshot (line 261) | pub fn screenshot<P: program::Program + 'static>(

FILE: test/src/simulator.rs
  type Simulator (line 25) | pub struct Simulator<'a, Message, Theme = core::Theme, Renderer = render...
  function new (line 39) | pub fn new(element: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function with_settings (line 44) | pub fn with_settings(
  function with_size (line 52) | pub fn with_size(
  function find (line 93) | pub fn find<S>(&mut self, selector: S) -> Result<S::Output, Error>
  function point_at (line 121) | pub fn point_at(&mut self, position: impl Into<Point>) {
  function click (line 130) | pub fn click<S>(&mut self, selector: S) -> Result<S::Output, Error>
  function tap_key (line 151) | pub fn tap_key(&mut self, key: impl Into<keyboard::Key>) -> event::Status {
  function typewrite (line 159) | pub fn typewrite(&mut self, text: &str) -> event::Status {
  function simulate (line 168) | pub fn simulate(&mut self, events: impl IntoIterator<Item = Event>) -> V...
  function snapshot (line 179) | pub fn snapshot(&mut self, theme: &Theme) -> Result<Snapshot, Error> {
  function into_messages (line 218) | pub fn into_messages(self) -> impl Iterator<Item = Message> + use<Messag...
  type Snapshot (line 225) | pub struct Snapshot {
    method matches_image (line 236) | pub fn matches_image(&self, path: impl AsRef<Path>) -> Result<bool, Er...
    method matches_hash (line 278) | pub fn matches_hash(&self, path: impl AsRef<Path>) -> Result<bool, Err...
    method path (line 303) | fn path(&self, path: impl AsRef<Path>, extension: &str) -> PathBuf {
  function simulator (line 321) | pub fn simulator<'a, Message, Theme, Renderer>(
  function click (line 332) | pub fn click() -> impl Iterator<Item = Event> {
  function press_key (line 341) | pub fn press_key(key: impl Into<keyboard::Key>, text: Option<SmolStr>) -...
  function release_key (line 358) | pub fn release_key(key: impl Into<keyboard::Key>) -> Event {
  function tap_key (line 373) | pub fn tap_key(
  function typewrite (line 383) | pub fn typewrite(text: &str) -> impl Iterator<Item = Event> + '_ {
  function load_font (line 389) | fn load_font(font: impl Into<Cow<'static, [u8]>>) -> Result<(), Error> {

FILE: tester/src/icon.rs
  constant FONT (line 6) | pub const FONT: &[u8] = include_bytes!("../fonts/iced_tester-icons.ttf");
  function cancel (line 8) | pub fn cancel<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function check (line 16) | pub fn check<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function floppy (line 24) | pub fn floppy<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function folder (line 32) | pub fn folder<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function keyboard (line 40) | pub fn keyboard<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function lightbulb (line 48) | pub fn lightbulb<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function mouse_pointer (line 56) | pub fn mouse_pointer<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function pause (line 64) | pub fn pause<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function pencil (line 72) | pub fn pencil<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function play (line 80) | pub fn play<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function record (line 88) | pub fn record<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function stop (line 96) | pub fn stop<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function tape (line 104) | pub fn tape<'a, Theme, Renderer>() -> Text<'a, Theme, Renderer>
  function icon (line 112) | fn icon<'a, Theme, Renderer>(codepoint: &'a str) -> Text<'a, Theme, Rend...

FILE: tester/src/lib.rs
  function attach (line 37) | pub fn attach<P: Program + 'static>(program: P) -> Attach<P> {
  type Attach (line 43) | pub struct Attach<P> {
  type State (line 52) | type State = Tester<P>;
  type Message (line 53) | type Message = Message<P>;
  type Theme (line 54) | type Theme = Theme;
  type Renderer (line 55) | type Renderer = P::Renderer;
  type Executor (line 56) | type Executor = P::Executor;
  method name (line 58) | fn name() -> &'static str {
  method settings (line 62) | fn settings(&self) -> Settings {
  method window (line 68) | fn window(&self) -> Option<window::Settings> {
  method boot (line 80) | fn boot(&self) -> (Self::State, Task<Self::Message>) {
  method update (line 84) | fn update(&self, state: &mut Self::State, message: Self::Message) -> Tas...
  method view (line 88) | fn view<'a>(
  method theme (line 96) | fn theme(&self, state: &Self::State, window: window::Id) -> Option<Theme> {
  type Tester (line 108) | pub struct Tester<P: Program> {
  type State (line 118) | enum State<P: Program> {
  type Outcome (line 138) | enum Outcome {
  type Message (line 145) | pub struct Message<P: Program>(Tick<P>);
  type Event (line 148) | enum Event {
  type Tick (line 163) | enum Tick<P: Program> {
  function new (line 172) | fn new(program: &P) -> Self {
  function is_busy (line 194) | fn is_busy(&self) -> bool {
  function update (line 205) | fn update(&mut self, program: &P, event: Event) -> Task<Tick<P>> {
  function confirm (line 388) | fn confirm(&mut self) {
  function theme (line 402) | fn theme(&self, program: &P, window: window::Id) -> Option<P::Theme> {
  function preset (line 413) | fn preset<'a>(&self, program: &'a P) -> Option<&'a program::Preset<P::St...
  function tick (line 422) | fn tick(&mut self, program: &P, tick: Tick<P>) -> Task<Tick<P>> {
  function view (line 531) | fn view<'a>(
  function controls (line 625) | fn controls(&self) -> Element<'_, Event, Theme, P::Renderer> {
  function labeled (line 795) | fn labeled<'a, Message, Renderer>(
  function labeled_with (line 811) | fn labeled_with<'a, Message, Renderer>(
  function labeled_slider (line 834) | fn labeled_slider<'a, Message, Renderer>(

FILE: tester/src/recorder.rs
  function recorder (line 16) | pub fn recorder<'a, Message, Theme, Renderer>(
  type Recorder (line 22) | pub struct Recorder<'a, Message, Theme, Renderer> {
  function new (line 29) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function on_record (line 37) | pub fn on_record(mut self, on_record: impl Fn(Interaction) -> Message + ...
  type State (line 43) | struct State {
  function tag (line 54) | fn tag(&self) -> tree::Tag {
  function state (line 58) | fn state(&self) -> tree::State {
  function children (line 65) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 69) | fn diff(&self, tree: &mut tree::Tree) {
  function size (line 73) | fn size(&self) -> Size<Length> {
  function size_hint (line 77) | fn size_hint(&self) -> Size<Length> {
  function update (line 81) | fn update(
  function layout (line 129) | fn layout(
  function draw (line 140) | fn draw(
  function mouse_interaction (line 177) | fn mouse_interaction(
  function operate (line 194) | fn operate(
  function overlay (line 206) | fn overlay<'a>(
  function from (line 247) | fn from(recorder: Recorder<'a, Message, Theme, Renderer>) -> Self {
  type Overlay (line 252) | struct Overlay<'a, Message, Theme, Renderer> {
  function layout (line 265) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function draw (line 269) | fn draw(
  function operate (line 296) | fn operate(
  function update (line 307) | fn update(
  function mouse_interaction (line 340) | fn mouse_interaction(
  function overlay (line 351) | fn overlay<'b>(
  function index (line 369) | fn index(&self) -> f32 {
  function record (line 374) | fn record<Message>(
  function find_text (line 438) | fn find_text(
  function highlight (line 483) | fn highlight(theme: &impl theme::Base) -> Color {

FILE: tiny_skia/src/engine.rs
  type Engine (line 8) | pub struct Engine {
    method new (line 18) | pub fn new() -> Self {
    method draw_quad (line 28) | pub fn draw_quad(
    method draw_text (line 285) | pub fn draw_text(
    method draw_primitive (line 441) | pub fn draw_primitive(
    method draw_image (line 511) | pub fn draw_image(
    method trim (line 595) | pub fn trim(&mut self) {
  function into_color (line 606) | pub fn into_color(color: Color) -> tiny_skia::Color {
  function into_transform (line 611) | fn into_transform(transformation: Transformation) -> tiny_skia::Transform {
  function rounded_rectangle (line 624) | fn rounded_rectangle(bounds: Rectangle, border_radius: [f32; 4]) -> tiny...
  function maybe_line_to (line 714) | fn maybe_line_to(path: &mut tiny_skia::PathBuilder, x: f32, y: f32) {
  function arc_to (line 720) | fn arc_to(
  function smoothstep (line 756) | fn smoothstep(a: f32, b: f32, x: f32) -> f32 {
  function rounded_box_sdf (line 762) | fn rounded_box_sdf(to_center: Vector, size: tiny_skia::Size, radii: &[f3...
  function adjust_clip_mask (line 776) | pub fn adjust_clip_mask(clip_mask: &mut tiny_skia::Mask, bounds: Rectang...

FILE: tiny_skia/src/geometry.rs
  type Geometry (line 13) | pub enum Geometry {
  type Cache (line 24) | pub struct Cache {
  type Cache (line 32) | type Cache = Cache;
  method load (line 34) | fn load(cache: &Cache) -> Self {
  method cache (line 38) | fn cache(self, _group: cache::Group, _previous: Option<Cache>) -> Cache {
  type Frame (line 57) | pub struct Frame {
    method new (line 67) | pub fn new(bounds: Rectangle) -> Self {
    type Geometry (line 80) | type Geometry = Geometry;
    method width (line 82) | fn width(&self) -> f32 {
    method height (line 86) | fn height(&self) -> f32 {
    method size (line 90) | fn size(&self) -> Size {
    method center (line 94) | fn center(&self) -> Point {
    method fill (line 98) | fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
    method fill_rectangle (line 115) | fn fill_rectangle(&mut self, top_left: Point, size: Size, fill: impl I...
    method stroke (line 137) | fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
    method stroke_rectangle (line 155) | fn stroke_rectangle<'a>(&mut self, top_left: Point, size: Size, stroke...
    method fill_text (line 159) | fn fill_text(&mut self, text: impl Into<geometry::Text>) {
    method stroke_text (line 218) | fn stroke_text<'a>(&mut self, text: impl Into<geometry::Text>, stroke:...
    method push_transform (line 225) | fn push_transform(&mut self) {
    method pop_transform (line 229) | fn pop_transform(&mut self) {
    method draft (line 233) | fn draft(&mut self, clip_bounds: Rectangle) -> Self {
    method paste (line 237) | fn paste(&mut self, frame: Self) {
    method translate (line 243) | fn translate(&mut self, translation: Vector) {
    method rotate (line 247) | fn rotate(&mut self, angle: impl Into<Radians>) {
    method scale (line 253) | fn scale(&mut self, scale: impl Into<f32>) {
    method scale_nonuniform (line 259) | fn scale_nonuniform(&mut self, scale: impl Into<Vector>) {
    method into_geometry (line 265) | fn into_geometry(self) -> Geometry {
    method draw_image (line 274) | fn draw_image(&mut self, bounds: Rectangle, image: impl Into<core::Ima...
    method draw_svg (line 288) | fn draw_svg(&mut self, bounds: Rectangle, svg: impl Into<Svg>) {
  function transform_rectangle (line 303) | fn transform_rectangle(
  function convert_path (line 333) | fn convert_path(path: &Path) -> Option<tiny_skia::Path> {
  function into_paint (line 396) | pub fn into_paint(style: Style) -> tiny_skia::Paint<'static> {
  function into_fill_rule (line 449) | pub fn into_fill_rule(rule: fill::Rule) -> tiny_skia::FillRule {
  function into_stroke (line 456) | pub fn into_stroke(stroke: &Stroke<'_>) -> tiny_skia::Stroke {

FILE: tiny_skia/src/layer.rs
  type Stack (line 11) | pub type Stack = layer::Stack<Layer>;
  type Layer (line 14) | pub struct Layer {
    method draw_quad (line 23) | pub fn draw_quad(
    method draw_paragraph (line 33) | pub fn draw_paragraph(
    method draw_editor (line 52) | pub fn draw_editor(
    method draw_text (line 71) | pub fn draw_text(
    method draw_text_raw (line 97) | pub fn draw_text_raw(&mut self, raw: graphics::text::Raw, transformati...
    method draw_text_group (line 106) | pub fn draw_text_group(
    method draw_text_cache (line 116) | pub fn draw_text_cache(
    method draw_image (line 126) | pub fn draw_image(&mut self, image: Image, transformation: Transformat...
    method draw_raster (line 145) | pub fn draw_raster(
    method draw_svg (line 164) | pub fn draw_svg(
    method draw_primitive_group (line 180) | pub fn draw_primitive_group(
    method draw_primitive_cache (line 193) | pub fn draw_primitive_cache(
    method damage (line 206) | pub fn damage(previous: &Self, current: &Self) -> Vec<Rectangle> {
    method with_bounds (line 316) | fn with_bounds(bounds: Rectangle) -> Self {
    method bounds (line 323) | fn bounds(&self) -> Rectangle {
    method flush (line 327) | fn flush(&mut self) {}
    method resize (line 329) | fn resize(&mut self, bounds: Rectangle) {
    method reset (line 333) | fn reset(&mut self) {
    method start (line 342) | fn start(&self) -> usize {
    method end (line 362) | fn end(&self) -> usize {
    method merge (line 382) | fn merge(&mut self, layer: &mut Self) {
  method default (line 304) | fn default() -> Self {
  type Item (line 391) | pub enum Item<T> {
  function transformation (line 398) | pub fn transformation(&self) -> Transformation {
  function clip_bounds (line 407) | pub fn clip_bounds(&self) -> Rectangle {
  function as_slice (line 414) | pub fn as_slice(&self) -> &[T] {

FILE: tiny_skia/src/lib.rs
  type Renderer (line 41) | pub struct Renderer {
    method new (line 48) | pub fn new(settings: renderer::Settings) -> Self {
    method layers (line 56) | pub fn layers(&mut self) -> &[Layer] {
    method draw (line 61) | pub fn draw(
    method start_layer (line 190) | fn start_layer(&mut self, bounds: Rectangle) {
    method end_layer (line 194) | fn end_layer(&mut self) {
    method start_transformation (line 198) | fn start_transformation(&mut self, transformation: Transformation) {
    method end_transformation (line 202) | fn end_transformation(&mut self) {
    method fill_quad (line 206) | fn fill_quad(&mut self, quad: renderer::Quad, background: impl Into<Ba...
    method allocate_image (line 211) | fn allocate_image(
    method hint (line 225) | fn hint(&mut self, _scale_factor: f32) {
    method scale_factor (line 230) | fn scale_factor(&self) -> Option<f32> {
    method reset (line 234) | fn reset(&mut self, new_bounds: Rectangle) {
    type Font (line 240) | type Font = Font;
    type Paragraph (line 241) | type Paragraph = Paragraph;
    type Editor (line 242) | type Editor = Editor;
    constant ICON_FONT (line 244) | const ICON_FONT: Font = Font::new("Iced-Icons");
    constant CHECKMARK_ICON (line 245) | const CHECKMARK_ICON: char = '\u{f00c}';
    constant ARROW_DOWN_ICON (line 246) | const ARROW_DOWN_ICON: char = '\u{e800}';
    constant ICED_LOGO (line 247) | const ICED_LOGO: char = '\u{e801}';
    constant SCROLL_UP_ICON (line 248) | const SCROLL_UP_ICON: char = '\u{e802}';
    constant SCROLL_DOWN_ICON (line 249) | const SCROLL_DOWN_ICON: char = '\u{e803}';
    constant SCROLL_LEFT_ICON (line 250) | const SCROLL_LEFT_ICON: char = '\u{e804}';
    constant SCROLL_RIGHT_ICON (line 251) | const SCROLL_RIGHT_ICON: char = '\u{e805}';
    method default_font (line 253) | fn default_font(&self) -> Self::Font {
    method default_size (line 257) | fn default_size(&self) -> Pixels {
    method fill_paragraph (line 261) | fn fill_paragraph(
    method fill_editor (line 273) | fn fill_editor(
    method fill_text (line 284) | fn fill_text(
    method fill_raw (line 297) | fn fill_raw(&mut self, raw: graphics::text::Raw) {
    type Geometry (line 305) | type Geometry = Geometry;
    type Frame (line 306) | type Frame = geometry::Frame;
    method new_frame (line 308) | fn new_frame(&self, bounds: Rectangle) -> Self::Frame {
    method draw_geometry (line 312) | fn draw_geometry(&mut self, geometry: Self::Geometry) {
    method draw_mesh (line 344) | fn draw_mesh(&mut self, _mesh: graphics::Mesh) {
    method draw_mesh_cache (line 348) | fn draw_mesh_cache(&mut self, _cache: iced_graphics::mesh::Cache) {
    type Handle (line 355) | type Handle = core::image::Handle;
    method load_image (line 357) | fn load_image(
    method measure_image (line 364) | fn measure_image(&self, handle: &Self::Handle) -> Option<crate::core::...
    method draw_image (line 368) | fn draw_image(&mut self, image: core::Image, bounds: Rectangle, clip_b...
    method measure_svg (line 376) | fn measure_svg(&self, handle: &core::svg::Handle) -> crate::core::Size...
    method draw_svg (line 380) | fn draw_svg(&mut self, svg: core::Svg, bounds: Rectangle, clip_bounds:...
    type Compositor (line 387) | type Compositor = window::Compositor;
    method new (line 391) | async fn new(settings: renderer::Settings, backend: Option<&str>) -> O...
    method name (line 399) | fn name(&self) -> String {
    method screenshot (line 403) | fn screenshot(

FILE: tiny_skia/src/primitive.rs
  type Primitive (line 4) | pub enum Primitive {
    method visible_bounds (line 27) | pub fn visible_bounds(&self) -> Rectangle {

FILE: tiny_skia/src/raster.rs
  type Pipeline (line 10) | pub struct Pipeline {
    method new (line 15) | pub fn new() -> Self {
    method load (line 21) | pub fn load(&self, handle: &raster::Handle) -> Result<raster::Allocati...
    method dimensions (line 29) | pub fn dimensions(&self, handle: &raster::Handle) -> Option<Size<u32>> {
    method draw (line 36) | pub fn draw(
    method trim_cache (line 76) | pub fn trim_cache(&mut self) {
  type Cache (line 82) | struct Cache {
    method allocate (line 88) | pub fn allocate(
    method trim (line 141) | fn trim(&mut self) {
  type Entry (line 148) | struct Entry {

FILE: tiny_skia/src/text.rs
  type Pipeline (line 15) | pub struct Pipeline {
    method new (line 21) | pub fn new() -> Self {
    method load_font (line 30) | pub fn load_font(&mut self, bytes: Cow<'static, [u8]>) {
    method draw_paragraph (line 39) | pub fn draw_paragraph(
    method draw_editor (line 66) | pub fn draw_editor(
    method draw_cached (line 93) | pub fn draw_cached(
    method draw_raw (line 156) | pub fn draw_raw(
    method trim_cache (line 179) | pub fn trim_cache(&mut self) {
  function draw (line 185) | fn draw(
  function from_color (line 234) | fn from_color(color: cosmic_text::Color) -> Color {
  type GlyphCache (line 241) | struct GlyphCache {
    constant TRIM_INTERVAL (line 248) | const TRIM_INTERVAL: usize = 300;
    constant CAPACITY_LIMIT (line 249) | const CAPACITY_LIMIT: usize = 16 * 1024;
    method new (line 251) | fn new() -> Self {
    method allocate (line 255) | fn allocate(
    method trim (line 328) | pub fn trim(&mut self) {

FILE: tiny_skia/src/vector.rs
  type Pipeline (line 15) | pub struct Pipeline {
    method new (line 20) | pub fn new() -> Self {
    method viewport_dimensions (line 26) | pub fn viewport_dimensions(&self, handle: &Handle) -> Size<u32> {
    method draw (line 33) | pub fn draw(
    method trim_cache (line 65) | pub fn trim_cache(&mut self) {
  type Cache (line 71) | struct Cache {
    method load (line 87) | fn load(&mut self, handle: &Handle) -> Option<&usvg::Tree> {
    method viewport_dimensions (line 122) | fn viewport_dimensions(&mut self, handle: &Handle) -> Option<Size<u32>> {
    method draw (line 129) | fn draw(
    method trim (line 204) | fn trim(&mut self) {
    method fmt (line 214) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type RasterKey (line 80) | struct RasterKey {

FILE: tiny_skia/src/window/compositor.rs
  type Compositor (line 12) | pub struct Compositor {
    type Renderer (line 30) | type Renderer = Renderer;
    type Surface (line 31) | type Surface = Surface;
    method with_backend (line 33) | async fn with_backend(
    method create_renderer (line 51) | fn create_renderer(&self, settings: renderer::Settings) -> Self::Rende...
    method create_surface (line 55) | fn create_surface<W: compositor::Window + Clone>(
    method configure_surface (line 78) | fn configure_surface(&mut self, surface: &mut Self::Surface, width: u3...
    method information (line 91) | fn information(&self) -> Information {
    method present (line 98) | fn present(
    method screenshot (line 115) | fn screenshot(
  type Surface (line 16) | pub struct Surface {
  type Frame (line 24) | struct Frame {
  function new (line 125) | pub fn new(display: impl compositor::Display) -> Compositor {
  function present (line 133) | pub fn present(
  function screenshot (line 205) | pub fn screenshot(

FILE: wgpu/src/buffer.rs
  constant MAX_WRITE_SIZE (line 5) | pub const MAX_WRITE_SIZE: usize = 100 * 1024;
  constant MAX_WRITE_SIZE_U64 (line 7) | const MAX_WRITE_SIZE_U64: NonZeroU64 =
  type Buffer (line 11) | pub struct Buffer<T> {
  function new (line 20) | pub fn new(
  function resize (line 44) | pub fn resize(&mut self, device: &wgpu::Device, new_count: usize) -> bool {
  function write (line 64) | pub fn write(
  function slice (line 105) | pub fn slice(&self, bounds: impl RangeBounds<wgpu::BufferAddress>) -> wg...
  function range (line 109) | pub fn range(&self, start: usize, end: usize) -> wgpu::BufferSlice<'_> {
  function next_copy_size (line 117) | fn next_copy_size<T>(amount: usize) -> u64 {

FILE: wgpu/src/color.rs
  function convert (line 5) | pub fn convert(

FILE: wgpu/src/engine.rs
  type Engine (line 10) | pub struct Engine {
    method new (line 25) | pub fn new(
    method create_image_cache (line 56) | pub fn create_image_cache(&self) -> crate::image::Cache {
    method trim (line 61) | pub fn trim(&mut self) {

FILE: wgpu/src/geometry.rs
  type Geometry (line 20) | pub enum Geometry {
  type Cache (line 30) | pub struct Cache {
  type Cache (line 37) | type Cache = Cache;
  method load (line 39) | fn load(cache: &Self::Cache) -> Self {
  method cache (line 43) | fn cache(self, group: cache::Group, previous: Option<Self::Cache>) -> Se...
  type Frame (line 96) | pub struct Frame {
    method new (line 109) | pub fn new(bounds: Rectangle) -> Frame {
    type Geometry (line 127) | type Geometry = Geometry;
    method width (line 130) | fn width(&self) -> f32 {
    method height (line 135) | fn height(&self) -> f32 {
    method size (line 140) | fn size(&self) -> Size {
    method center (line 145) | fn center(&self) -> Point {
    method fill (line 149) | fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
    method fill_rectangle (line 170) | fn fill_rectangle(&mut self, top_left: Point, size: Size, fill: impl I...
    method stroke (line 200) | fn stroke<'a>(&mut self, path: &Path, stroke: impl Into<Stroke<'a>>) {
    method stroke_rectangle (line 231) | fn stroke_rectangle<'a>(&mut self, top_left: Point, size: Size, stroke...
    method stroke_text (line 265) | fn stroke_text<'a>(&mut self, text: impl Into<geometry::Text>, stroke:...
    method fill_text (line 272) | fn fill_text(&mut self, text: impl Into<geometry::Text>) {
    method translate (line 325) | fn translate(&mut self, translation: Vector) {
    method rotate (line 334) | fn rotate(&mut self, angle: impl Into<Radians>) {
    method scale (line 343) | fn scale(&mut self, scale: impl Into<f32>) {
    method scale_nonuniform (line 350) | fn scale_nonuniform(&mut self, scale: impl Into<Vector>) {
    method push_transform (line 356) | fn push_transform(&mut self) {
    method pop_transform (line 360) | fn pop_transform(&mut self) {
    method draft (line 364) | fn draft(&mut self, clip_bounds: Rectangle) -> Frame {
    method paste (line 368) | fn paste(&mut self, frame: Frame) {
    method into_geometry (line 377) | fn into_geometry(mut self) -> Self::Geometry {
    method draw_image (line 388) | fn draw_image(&mut self, bounds: Rectangle, image: impl Into<core::Ima...
    method draw_svg (line 403) | fn draw_svg(&mut self, bounds: Rectangle, svg: impl Into<Svg>) {
  type Buffer (line 418) | enum Buffer {
  type BufferStack (line 423) | struct BufferStack {
    method new (line 428) | fn new() -> Self {
    method get_mut (line 432) | fn get_mut(&mut self, style: &Style) -> &mut Buffer {
    method get_fill (line 453) | fn get_fill<'a>(
    method get_stroke (line 476) | fn get_stroke<'a>(
    method into_meshes (line 499) | fn into_meshes(self, clip_bounds: Rectangle) -> impl Iterator<Item = M...
  type Transforms (line 525) | struct Transforms {
  type Transform (line 531) | struct Transform(lyon::math::Transform);
    method is_identity (line 534) | fn is_identity(&self) -> bool {
    method is_scale_translation (line 538) | fn is_scale_translation(&self) -> bool {
    method scale (line 542) | fn scale(&self) -> (f32, f32) {
    method transform_point (line 546) | fn transform_point(&self, point: Point) -> Point {
    method transform_style (line 557) | fn transform_style(&self, style: Style) -> Style {
    method transform_gradient (line 564) | fn transform_gradient(&self, mut gradient: Gradient) -> Gradient {
    method transform_rectangle (line 575) | fn transform_rectangle(&self, rectangle: Rectangle) -> (Rectangle, Rad...
  type GradientVertex2DBuilder (line 585) | struct GradientVertex2DBuilder {
    method new_vertex (line 590) | fn new_vertex(&mut self, vertex: tessellation::FillVertex<'_>) -> mesh...
    method new_vertex (line 601) | fn new_vertex(&mut self, vertex: tessellation::StrokeVertex<'_, '_>) -...
  type TriangleVertex2DBuilder (line 611) | struct TriangleVertex2DBuilder(color::Packed);
    method new_vertex (line 614) | fn new_vertex(&mut self, vertex: tessellation::FillVertex<'_>) -> mesh...
    method new_vertex (line 625) | fn new_vertex(&mut self, vertex: tessellation::StrokeVertex<'_, '_>) -...
  function into_line_join (line 635) | fn into_line_join(line_join: LineJoin) -> lyon::tessellation::LineJoin {
  function into_line_cap (line 643) | fn into_line_cap(line_cap: LineCap) -> lyon::tessellation::LineCap {
  function into_fill_rule (line 651) | fn into_fill_rule(rule: fill::Rule) -> lyon::tessellation::FillRule {
  function dashed (line 658) | pub(super) fn dashed(path: &Path, line_dash: LineDash<'_>) -> Path {

FILE: wgpu/src/image/atlas.rs
  constant DEFAULT_SIZE (line 13) | pub const DEFAULT_SIZE: u32 = 2048;
  constant MAX_SIZE (line 14) | pub const MAX_SIZE: u32 = 2048;
  type Atlas (line 22) | pub struct Atlas {
    method new (line 33) | pub fn new(
    method with_size (line 41) | pub fn with_size(
    method bind_group (line 105) | pub fn bind_group(&self) -> &Arc<wgpu::BindGroup> {
    method upload (line 109) | pub fn upload(
    method remove (line 164) | pub fn remove(&mut self, entry: &Entry) {
    method allocate (line 179) | fn allocate(&mut self, width: u32, height: u32) -> Option<Entry> {
    method deallocate (line 284) | fn deallocate(&mut self, allocation: &Allocation) {
    method upload_allocation (line 305) | fn upload_allocation(
    method grow (line 425) | fn grow(

FILE: wgpu/src/image/atlas/allocation.rs
  type Allocation (line 5) | pub enum Allocation {
    method position (line 18) | pub fn position(&self) -> (u32, u32) {
    method size (line 25) | pub fn size(&self) -> Size<u32> {
    method padding (line 32) | pub fn padding(&self) -> Size<u32> {
    method layer (line 39) | pub fn layer(&self) -> usize {
    method atlas_size (line 46) | pub fn atlas_size(&self) -> u32 {

FILE: wgpu/src/image/atlas/allocator.rs
  type Allocator (line 5) | pub struct Allocator {
    constant PADDING (line 11) | const PADDING: u32 = 1;
    method new (line 13) | pub fn new(size: u32) -> Allocator {
    method allocate (line 22) | pub fn allocate(&mut self, width: u32, height: u32) -> Option<Region> {
    method deallocate (line 57) | pub fn deallocate(&mut self, region: &Region) {
    method is_empty (line 63) | pub fn is_empty(&self) -> bool {
    method allocations (line 67) | pub fn allocations(&self) -> usize {
    method fmt (line 96) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Region (line 72) | pub struct Region {
    method position (line 78) | pub fn position(&self) -> (u32, u32) {
    method size (line 84) | pub fn size(&self) -> core::Size<u32> {
    method padding (line 90) | pub fn padding(&self) -> crate::core::Size<u32> {
    method fmt (line 102) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: wgpu/src/image/atlas/entry.rs
  type Entry (line 5) | pub enum Entry {
    method size (line 15) | pub fn size(&self) -> Size<u32> {
  type Fragment (line 24) | pub struct Fragment {

FILE: wgpu/src/image/atlas/layer.rs
  type Layer (line 4) | pub enum Layer {
    method is_empty (line 11) | pub fn is_empty(&self) -> bool {
    method allocations (line 15) | pub fn allocations(&self) -> usize {

FILE: wgpu/src/image/cache.rs
  type Cache (line 13) | pub struct Cache {
    method new (line 24) | pub fn new(
    method allocate_image (line 50) | pub fn allocate_image(
    method load_image (line 91) | pub fn load_image(
    method measure_image (line 169) | pub fn measure_image(&mut self, handle: &core::image::Handle) -> Optio...
    method measure_svg (line 185) | pub fn measure_svg(&mut self, handle: &core::svg::Handle) -> Size<u32> {
    method upload_raster (line 191) | pub fn upload_raster(
    method upload_vector (line 253) | pub fn upload_vector(
    method trim (line 268) | pub fn trim(&mut self) {
    method receive (line 283) | pub fn receive(&mut self) {
  method drop (line 338) | fn drop(&mut self) {
  type Raster (line 344) | struct Raster {
  type Callback (line 351) | type Callback = Box<dyn FnOnce(Result<core::image::Allocation, core::ima...
  function load_image (line 354) | fn load_image<'a>(
  type Worker (line 393) | pub struct Worker {
    method new (line 401) | pub fn new(
    method load (line 434) | pub fn load(&self, handle: &image::Handle, is_allocation: bool) {
    method upload (line 441) | pub fn upload(&self, handle: &image::Handle, image: raster::Image) {
    method drop (line 450) | pub fn drop(&self, bind_group: Arc<wgpu::BindGroup>) {
    method try_recv (line 454) | pub fn try_recv(&self) -> Result<Work, mpsc::TryRecvError> {
    method quit (line 458) | pub fn quit(&mut self) {
  type Instance (line 465) | pub struct Instance {
    method run (line 506) | fn run(mut self) {
    method upload (line 552) | fn upload(
  type Job (line 478) | enum Job {
  type Work (line 493) | pub enum Work {

FILE: wgpu/src/image/mod.rs
  type Batch (line 24) | pub type Batch = Vec<Image>;
  type Pipeline (line 27) | pub struct Pipeline {
    method new (line 37) | pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, backend...
    method create_cache (line 178) | pub fn create_cache(&self, device: &wgpu::Device, queue: &wgpu::Queue,...
  type State (line 190) | pub struct State {
    method new (line 198) | pub fn new() -> Self {
    method prepare (line 202) | pub fn prepare(
    method render (line 344) | pub fn render<'a>(
    method trim (line 360) | pub fn trim(&mut self) {
  type Layer (line 370) | struct Layer {
    method new (line 388) | fn new(
    method prepare (line 458) | fn prepare(
    method push (line 496) | fn push(&mut self, atlas: &Arc<wgpu::BindGroup>, nearest: &[Instance],...
    method render (line 520) | fn render<'a>(&'a self, render_pass: &mut wgpu::RenderPass<'a>) {
    method clear (line 548) | fn clear(&mut self) {
  type Group (line 382) | struct Group {
  type Instance (line 559) | struct Instance {
    constant INITIAL (line 572) | pub const INITIAL: usize = 20;
  type Uniforms (line 577) | struct Uniforms {
  function add_instances (line 581) | fn add_instances(
  function add_instance (line 653) | fn add_instance(

FILE: wgpu/src/image/null.rs
  type Batch (line 4) | pub struct Batch;
    method push (line 7) | pub fn push(&mut self, _image: Image) {}
    method clear (line 9) | pub fn clear(&mut self) {}
    method is_empty (line 11) | pub fn is_empty(&self) -> bool {
    method append (line 15) | pub fn append(&mut self, _batch: &mut Self) {}

FILE: wgpu/src/image/raster.rs
  type Image (line 9) | pub type Image = graphics::image::Buffer;
  type Memory (line 13) | pub enum Memory {
    method load (line 26) | pub fn load(handle: &image::Handle) -> Self {
    method dimensions (line 33) | pub fn dimensions(&self) -> Size<u32> {
    method host (line 45) | pub fn host(&self) -> Option<Image> {
  type Cache (line 54) | pub struct Cache {
    method get_mut (line 61) | pub fn get_mut(&mut self, handle: &image::Handle) -> Option<&mut Memor...
    method insert (line 67) | pub fn insert(&mut self, handle: &image::Handle, memory: Memory) {
    method contains (line 74) | pub fn contains(&self, handle: &image::Handle) -> bool {
    method trim (line 78) | pub fn trim(&mut self, atlas: &mut Atlas, on_drop: impl Fn(Arc<wgpu::B...

FILE: wgpu/src/image/vector.rs
  type Svg (line 13) | pub enum Svg {
    method viewport_dimensions (line 22) | pub fn viewport_dimensions(&self) -> Size<u32> {
    method fmt (line 208) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Cache (line 36) | pub struct Cache {
    method load (line 49) | pub fn load(&mut self, handle: &svg::Handle) -> &Svg {
    method upload (line 90) | pub fn upload(
    method trim (line 183) | pub fn trim(&mut self, atlas: &mut Atlas) {
  type ColorFilter (line 45) | type ColorFilter = Option<[u8; 4]>;

FILE: wgpu/src/layer.rs
  type Stack (line 14) | pub type Stack = layer::Stack<Layer>;
  type Layer (line 17) | pub struct Layer {
    method is_empty (line 29) | pub fn is_empty(&self) -> bool {
    method draw_quad (line 39) | pub fn draw_quad(
    method draw_paragraph (line 62) | pub fn draw_paragraph(
    method draw_editor (line 81) | pub fn draw_editor(
    method draw_text (line 100) | pub fn draw_text(
    method draw_text_raw (line 126) | pub fn draw_text_raw(&mut self, raw: graphics::text::Raw, transformati...
    method draw_image (line 135) | pub fn draw_image(&mut self, image: Image, transformation: Transformat...
    method draw_raster (line 154) | pub fn draw_raster(
    method draw_svg (line 173) | pub fn draw_svg(
    method draw_mesh (line 189) | pub fn draw_mesh(&mut self, mut mesh: Mesh, transformation: Transforma...
    method draw_mesh_group (line 206) | pub fn draw_mesh_group(&mut self, meshes: Vec<Mesh>, transformation: T...
    method draw_mesh_cache (line 215) | pub fn draw_mesh_cache(&mut self, cache: mesh::Cache, transformation: ...
    method draw_text_group (line 224) | pub fn draw_text_group(&mut self, text: Vec<Text>, transformation: Tra...
    method draw_text_cache (line 233) | pub fn draw_text_cache(&mut self, cache: text::Cache, transformation: ...
    method draw_primitive (line 242) | pub fn draw_primitive(
    method flush_meshes (line 254) | fn flush_meshes(&mut self) {
    method flush_text (line 263) | fn flush_text(&mut self) {
    method with_bounds (line 274) | fn with_bounds(bounds: Rectangle) -> Self {
    method bounds (line 281) | fn bounds(&self) -> Rectangle {
    method flush (line 285) | fn flush(&mut self) {
    method resize (line 290) | fn resize(&mut self, bounds: Rectangle) {
    method reset (line 294) | fn reset(&mut self) {
    method start (line 306) | fn start(&self) -> usize {
    method end (line 330) | fn end(&self) -> usize {
    method merge (line 354) | fn merge(&mut self, layer: &mut Self) {
  method default (line 364) | fn default() -> Self {

FILE: wgpu/src/lib.rs
  type Renderer (line 72) | pub struct Renderer {
    method new (line 95) | pub fn new(engine: Engine, settings: renderer::Settings) -> Self {
    method draw (line 124) | fn draw(
    method present (line 156) | pub fn present(
    method screenshot (line 174) | pub fn screenshot(&mut self, viewport: &Viewport, background_color: Co...
    method prepare (line 278) | fn prepare(&mut self, encoder: &mut wgpu::CommandEncoder, viewport: &V...
    method render (line 392) | fn render(
    method start_layer (line 640) | fn start_layer(&mut self, bounds: Rectangle) {
    method end_layer (line 644) | fn end_layer(&mut self) {
    method start_transformation (line 648) | fn start_transformation(&mut self, transformation: Transformation) {
    method end_transformation (line 652) | fn end_transformation(&mut self) {
    method fill_quad (line 656) | fn fill_quad(&mut self, quad: core::renderer::Quad, background: impl I...
    method allocate_image (line 661) | fn allocate_image(
    method hint (line 672) | fn hint(&mut self, scale_factor: f32) {
    method scale_factor (line 676) | fn scale_factor(&self) -> Option<f32> {
    method tick (line 680) | fn tick(&mut self) {
    method reset (line 685) | fn reset(&mut self, new_bounds: Rectangle) {
    type Font (line 691) | type Font = Font;
    type Paragraph (line 692) | type Paragraph = Paragraph;
    type Editor (line 693) | type Editor = Editor;
    constant ICON_FONT (line 695) | const ICON_FONT: Font = Font::new("Iced-Icons");
    constant CHECKMARK_ICON (line 696) | const CHECKMARK_ICON: char = '\u{f00c}';
    constant ARROW_DOWN_ICON (line 697) | const ARROW_DOWN_ICON: char = '\u{e800}';
    constant ICED_LOGO (line 698) | const ICED_LOGO: char = '\u{e801}';
    constant SCROLL_UP_ICON (line 699) | const SCROLL_UP_ICON: char = '\u{e802}';
    constant SCROLL_DOWN_ICON (line 700) | const SCROLL_DOWN_ICON: char = '\u{e803}';
    constant SCROLL_LEFT_ICON (line 701) | const SCROLL_LEFT_ICON: char = '\u{e804}';
    constant SCROLL_RIGHT_ICON (line 702) | const SCROLL_RIGHT_ICON: char = '\u{e805}';
    method default_font (line 704) | fn default_font(&self) -> Self::Font {
    method default_size (line 708) | fn default_size(&self) -> Pixels {
    method fill_paragraph (line 712) | fn fill_paragraph(
    method fill_editor (line 724) | fn fill_editor(
    method fill_text (line 735) | fn fill_text(
    method fill_raw (line 748) | fn fill_raw(&mut self, raw: graphics::text::Raw) {
    type Handle (line 756) | type Handle = core::image::Handle;
    method load_image (line 758) | fn load_image(
    method measure_image (line 767) | fn measure_image(&self, handle: &Self::Handle) -> Option<core::Size<u3...
    method draw_image (line 771) | fn draw_image(&mut self, image: core::Image, bounds: Rectangle, clip_b...
    method measure_svg (line 779) | fn measure_svg(&self, handle: &core::svg::Handle) -> core::Size<u32> {
    method draw_svg (line 783) | fn draw_svg(&mut self, svg: core::Svg, bounds: Rectangle, clip_bounds:...
    method draw_mesh (line 790) | fn draw_mesh(&mut self, mesh: graphics::Mesh) {
    method draw_mesh_cache (line 805) | fn draw_mesh_cache(&mut self, cache: mesh::Cache) {
    type Geometry (line 813) | type Geometry = Geometry;
    type Frame (line 814) | type Frame = geometry::Frame;
    method new_frame (line 816) | fn new_frame(&self, bounds: Rectangle) -> Self::Frame {
    method draw_geometry (line 820) | fn draw_geometry(&mut self, geometry: Self::Geometry) {
    method draw_primitive (line 857) | fn draw_primitive(&mut self, bounds: Rectangle, primitive: impl Primit...
    method new (line 868) | async fn new(settings: renderer::Settings, backend: Option<&str>) -> O...
    method name (line 919) | fn name(&self) -> String {
    method screenshot (line 923) | fn screenshot(
  type Compositor (line 864) | type Compositor = window::Compositor;

FILE: wgpu/src/primitive.rs
  type Batch (line 11) | pub type Batch = Vec<Instance>;
  type Primitive (line 14) | pub trait Primitive: Debug + MaybeSend + MaybeSync + 'static {
    method prepare (line 25) | fn prepare(
    method draw (line 47) | fn draw(&self, _pipeline: &Self::Pipeline, _render_pass: &mut wgpu::Re...
    method render (line 56) | fn render(
  type Pipeline (line 67) | pub trait Pipeline: Any + MaybeSend + MaybeSync {
    method new (line 72) | fn new(device: &wgpu::Device, queue: &wgpu::Queue, format: wgpu::Textu...
    method trim (line 79) | fn trim(&mut self) {}
  type Stored (line 82) | pub(crate) trait Stored: Debug + MaybeSend + MaybeSync + 'static {
    method prepare (line 83) | fn prepare(
    method draw (line 93) | fn draw(&self, storage: &Storage, render_pass: &mut wgpu::RenderPass<'...
    method render (line 95) | fn render(
    method prepare (line 110) | fn prepare(
    method draw (line 133) | fn draw(&self, storage: &Storage, render_pass: &mut wgpu::RenderPass<'...
    method render (line 143) | fn render(
  type BlackBox (line 105) | struct BlackBox<P: Primitive> {
  type Instance (line 163) | pub struct Instance {
    method new (line 173) | pub fn new(bounds: Rectangle, primitive: impl Primitive) -> Self {
  type Renderer (line 182) | pub trait Renderer: core::Renderer {
    method draw_primitive (line 184) | fn draw_primitive(&mut self, bounds: Rectangle, primitive: impl Primit...
  type Storage (line 189) | pub struct Storage {
    method has (line 195) | pub fn has<T: 'static>(&self) -> bool {
    method store (line 200) | pub fn store<T: 'static, P: Pipeline>(&mut self, pipeline: P) {
    method get (line 205) | pub fn get<T: 'static>(&self) -> Option<&dyn Any> {
    method get_mut (line 212) | pub fn get_mut<T: 'static>(&mut self) -> Option<&mut dyn Any> {
    method trim (line 219) | pub fn trim(&mut self) {

FILE: wgpu/src/quad.rs
  constant INITIAL_INSTANCES (line 15) | const INITIAL_INSTANCES: usize = 2_000;
  type Quad (line 20) | pub struct Quad {
  type Pipeline (line 50) | pub struct Pipeline {
    method new (line 135) | pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat) -> Pipe...
  type State (line 57) | pub struct State {
    method new (line 63) | pub fn new() -> Self {
    method prepare (line 67) | pub fn prepare(
    method render (line 88) | pub fn render<'a>(
    method trim (line 129) | pub fn trim(&mut self) {
  type Layer (line 161) | pub struct Layer {
    method new (line 169) | pub fn new(device: &wgpu::Device, constant_layout: &wgpu::BindGroupLay...
    method prepare (line 194) | pub fn prepare(
    method update (line 215) | pub fn update(
  type Batch (line 237) | pub struct Batch {
    method is_empty (line 253) | pub fn is_empty(&self) -> bool {
    method add (line 258) | pub fn add(&mut self, quad: Quad, background: &Background) {
    method clear (line 291) | pub fn clear(&mut self) {
    method append (line 297) | pub fn append(&mut self, batch: &mut Batch) {
  type Order (line 249) | type Order = Vec<(Kind, usize)>;
  type Kind (line 306) | enum Kind {
  function color_target_state (line 313) | fn color_target_state(format: wgpu::TextureFormat) -> [Option<wgpu::Colo...
  type Uniforms (line 323) | struct Uniforms {
    method new (line 332) | fn new(transformation: Transformation, scale: f32) -> Uniforms {
  method default (line 342) | fn default() -> Self {

FILE: wgpu/src/quad/gradient.rs
  type Gradient (line 11) | pub struct Gradient {
  type Layer (line 26) | pub struct Layer {
    method new (line 32) | pub fn new(device: &wgpu::Device) -> Self {
    method prepare (line 46) | pub fn prepare(
  type Pipeline (line 61) | pub struct Pipeline {
    method new (line 68) | pub fn new(
    method render (line 161) | pub fn render<'a>(

FILE: wgpu/src/quad/solid.rs
  type Solid (line 11) | pub struct Solid {
  type Layer (line 20) | pub struct Layer {
    method new (line 26) | pub fn new(device: &wgpu::Device) -> Self {
    method prepare (line 40) | pub fn prepare(
  type Pipeline (line 55) | pub struct Pipeline {
    method new (line 60) | pub fn new(
    method render (line 142) | pub fn render<'a>(

FILE: wgpu/src/text.rs
  constant COLOR_MODE (line 16) | const COLOR_MODE: cryoglyph::ColorMode = if color::GAMMA_CORRECTION {
  type Batch (line 22) | pub type Batch = Vec<Item>;
  type Item (line 25) | pub enum Item {
  type Cache (line 37) | pub struct Cache {
    method new (line 48) | pub fn new(group: cache::Group, text: Vec<Text>) -> Option<Self> {
    method update (line 63) | pub fn update(&mut self, text: Vec<Text>) {
  type Id (line 45) | pub struct Id(u64);
  type Upload (line 73) | struct Upload {
  type Storage (line 84) | pub struct Storage {
    method get (line 97) | fn get(&self, cache: &Cache) -> Option<(&cryoglyph::TextAtlas, &Upload...
    method prepare (line 108) | fn prepare(
    method trim (line 219) | pub fn trim(&mut self) {
  type Group (line 89) | struct Group {
  type Viewport (line 256) | pub struct Viewport(cryoglyph::Viewport);
    method update (line 259) | pub fn update(&mut self, queue: &wgpu::Queue, resolution: Size<u32>) {
  type Pipeline (line 271) | pub struct Pipeline {
    method new (line 278) | pub fn new(device: &wgpu::Device, queue: &wgpu::Queue, format: wgpu::T...
    method create_viewport (line 290) | pub fn create_viewport(&self, device: &wgpu::Device) -> Viewport {
    method trim (line 294) | pub fn trim(&self) {
  type State (line 300) | pub struct State {
    method new (line 308) | pub fn new() -> Self {
    method prepare (line 312) | pub fn prepare(
    method render (line 385) | pub fn render<'a>(
    method trim (line 424) | pub fn trim(&mut self) {
  function prepare (line 432) | fn prepare(

FILE: wgpu/src/triangle.rs
  constant INITIAL_INDEX_COUNT (line 13) | const INITIAL_INDEX_COUNT: usize = 1_000;
  constant INITIAL_VERTEX_COUNT (line 14) | const INITIAL_VERTEX_COUNT: usize = 1_000;
  type Batch (line 16) | pub type Batch = Vec<Item>;
  type Item (line 19) | pub enum Item {
  type Upload (line 31) | struct Upload {
  type Storage (line 39) | pub struct Storage {
    method new (line 44) | pub fn new() -> Self {
    method get (line 48) | fn get(&self, cache: &mesh::Cache) -> Option<&Upload> {
    method prepare (line 56) | fn prepare(
    method trim (line 118) | pub fn trim(&mut self) {
  type Pipeline (line 125) | pub struct Pipeline {
    method new (line 271) | pub fn new(
    method new (line 678) | pub fn new(
    method new (line 810) | pub fn new(
  type State (line 131) | pub struct State {
    method new (line 139) | pub fn new(device: &wgpu::Device, pipeline: &Pipeline) -> Self {
    method prepare (line 151) | pub fn prepare(
    method render (line 210) | pub fn render(
    method trim (line 263) | pub fn trim(&mut self) {
  function render (line 284) | fn render<'a>(
  type Layer (line 333) | pub struct Layer {
    method new (line 340) | fn new(device: &wgpu::Device, solid: &solid::Pipeline, gradient: &grad...
    method prepare (line 353) | fn prepare(
    method render (line 451) | fn render<'a>(
    method new (line 633) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 657) | pub fn bind_group(
    method new (line 765) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 789) | pub fn bind_group(
  function fragment_target (line 554) | fn fragment_target(texture_format: wgpu::TextureFormat) -> wgpu::ColorTa...
  function primitive_state (line 562) | fn primitive_state() -> wgpu::PrimitiveState {
  function multisample_state (line 570) | fn multisample_state(antialiasing: Option<Antialiasing>) -> wgpu::Multis...
  type Uniforms (line 580) | pub struct Uniforms {
    method new (line 588) | pub fn new(transform: Transformation) -> Self {
    method entry (line 595) | pub fn entry() -> wgpu::BindGroupLayoutEntry {
    method min_size (line 608) | pub fn min_size() -> Option<wgpu::BufferSize> {
  type Pipeline (line 620) | pub struct Pipeline {
    method new (line 271) | pub fn new(
    method new (line 678) | pub fn new(
    method new (line 810) | pub fn new(
  type Layer (line 626) | pub struct Layer {
    method new (line 340) | fn new(device: &wgpu::Device, solid: &solid::Pipeline, gradient: &grad...
    method prepare (line 353) | fn prepare(
    method render (line 451) | fn render<'a>(
    method new (line 633) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 657) | pub fn bind_group(
    method new (line 765) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 789) | pub fn bind_group(
  type Pipeline (line 752) | pub struct Pipeline {
    method new (line 271) | pub fn new(
    method new (line 678) | pub fn new(
    method new (line 810) | pub fn new(
  type Layer (line 758) | pub struct Layer {
    method new (line 340) | fn new(device: &wgpu::Device, solid: &solid::Pipeline, gradient: &grad...
    method prepare (line 353) | fn prepare(
    method render (line 451) | fn render<'a>(
    method new (line 633) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 657) | pub fn bind_group(
    method new (line 765) | pub fn new(device: &wgpu::Device, constants_layout: &wgpu::BindGroupLa...
    method bind_group (line 789) | pub fn bind_group(

FILE: wgpu/src/triangle/msaa.rs
  type Pipeline (line 8) | pub struct Pipeline {
    method new (line 19) | pub fn new(
    method targets (line 120) | fn targets(&self, device: &wgpu::Device, region_size: Size<u32>) -> Ta...
    method render_pass (line 141) | pub fn render_pass<'a>(&self, encoder: &'a mut wgpu::CommandEncoder) -...
  type Targets (line 165) | struct Targets {
    method new (line 173) | pub fn new(
  type Ratio (line 232) | struct Ratio {
  type State (line 240) | pub struct State {
    method new (line 247) | pub fn new(device: &wgpu::Device, pipeline: &Pipeline) -> Self {
    method prepare (line 277) | pub fn prepare(
    method render (line 308) | pub fn render(

FILE: wgpu/src/window/compositor.rs
  type Compositor (line 11) | pub struct Compositor {
    method request (line 50) | pub async fn request<W: compositor::Window>(
    type Renderer (line 255) | type Renderer = Renderer;
    type Surface (line 256) | type Surface = wgpu::Surface<'static>;
    method with_backend (line 258) | async fn with_backend(
    method create_renderer (line 288) | fn create_renderer(&self, settings: renderer::Settings) -> Self::Rende...
    method create_surface (line 292) | fn create_surface<W: compositor::Window>(
    method configure_surface (line 310) | fn configure_surface(&mut self, surface: &mut Self::Surface, width: u3...
    method information (line 326) | fn information(&self) -> compositor::Information {
    method present (line 335) | fn present(
    method screenshot (line 352) | fn screenshot(
  type Error (line 22) | pub enum Error {
  function from (line 38) | fn from(error: Error) -> Self {
  function new (line 209) | pub async fn new<W: compositor::Window>(
  function present (line 218) | pub fn present(
  type Settings (line 364) | pub struct Settings {
    method from (line 390) | fn from(settings: compositor::Settings) -> Self {
  method default (line 380) | fn default() -> Settings {
  function present_mode_from_env (line 415) | pub fn present_mode_from_env() -> Option<wgpu::PresentMode> {

FILE: widget/src/action.rs
  type Action (line 7) | pub struct Action<Message> {
  function new (line 14) | fn new() -> Self {
  function capture (line 27) | pub fn capture() -> Self {
  function publish (line 38) | pub fn publish(message: Message) -> Self {
  function request_redraw (line 47) | pub fn request_redraw() -> Self {
  function request_redraw_at (line 59) | pub fn request_redraw_at(at: Instant) -> Self {
  function and_capture (line 67) | pub fn and_capture(mut self) -> Self {
  function into_inner (line 76) | pub fn into_inner(self) -> (Option<Message>, window::RedrawRequest, even...

FILE: widget/src/button.rs
  type Button (line 71) | pub struct Button<'a, Message, Theme = crate::Theme, Renderer = crate::R...
  type OnPress (line 86) | enum OnPress<'a, Message> {
  function get (line 92) | fn get(&self) -> Message {
  function new (line 106) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function width (line 123) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 129) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function padding (line 135) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function on_press (line 143) | pub fn on_press(mut self, on_press: Message) -> Self {
  function on_press_with (line 156) | pub fn on_press_with(mut self, on_press: impl Fn() -> Message + 'a) -> S...
  function on_press_maybe (line 165) | pub fn on_press_maybe(mut self, on_press: Option<Message>) -> Self {
  function clip (line 172) | pub fn clip(mut self, clip: bool) -> Self {
  function style (line 179) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 190) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  type State (line 197) | struct State {
  function tag (line 208) | fn tag(&self) -> tree::Tag {
  function state (line 212) | fn state(&self) -> tree::State {
  function children (line 216) | fn children(&self) -> Vec<Tree> {
  function diff (line 220) | fn diff(&self, tree: &mut Tree) {
  function size (line 224) | fn size(&self) -> Size<Length> {
  function layout (line 231) | fn layout(
  function operate (line 244) | fn operate(
  function update (line 262) | fn update(
  function draw (line 348) | fn draw(
  function mouse_interaction (line 395) | fn mouse_interaction(
  function overlay (line 412) | fn overlay<'b>(
  function from (line 437) | fn from(button: Button<'a, Message, Theme, Renderer>) -> Self {
  constant DEFAULT_PADDING (line 443) | pub const DEFAULT_PADDING: Padding = Padding {
  type Status (line 452) | pub enum Status {
  type Style (line 468) | pub struct Style {
    method with_background (line 483) | pub fn with_background(self, background: impl Into<Background>) -> Self {
  method default (line 492) | fn default() -> Self {
  type Catalog (line 552) | pub trait Catalog {
    method default (line 557) | fn default<'a>() -> Self::Class<'a>;
    method style (line 560) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 567) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 569) | fn default<'a>() -> Self::Class<'a> {
    method style (line 573) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 564) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function primary (line 579) | pub fn primary(theme: &Theme, status: Status) -> Style {
  function secondary (line 594) | pub fn secondary(theme: &Theme, status: Status) -> Style {
  function success (line 609) | pub fn success(theme: &Theme, status: Status) -> Style {
  function warning (line 624) | pub fn warning(theme: &Theme, status: Status) -> Style {
  function danger (line 639) | pub fn danger(theme: &Theme, status: Status) -> Style {
  function text (line 654) | pub fn text(theme: &Theme, status: Status) -> Style {
  function background (line 673) | pub fn background(theme: &Theme, status: Status) -> Style {
  function subtle (line 692) | pub fn subtle(theme: &Theme, status: Status) -> Style {
  function styled (line 710) | fn styled(pair: palette::Pair) -> Style {
  function disabled (line 719) | fn disabled(style: Style) -> Style {

FILE: widget/src/canvas.rs
  type Cache (line 78) | pub type Cache<Renderer = crate::Renderer> = geometry::Cache<Renderer>;
  type Geometry (line 81) | pub type Geometry<Renderer = crate::Renderer> = <Renderer as geometry::R...
  type Frame (line 84) | pub type Frame<Renderer = crate::Renderer> = geometry::Frame<Renderer>;
  type Canvas (line 137) | pub struct Canvas<P, Message, Theme = crate::Theme, Renderer = crate::Re...
  constant DEFAULT_SIZE (line 156) | const DEFAULT_SIZE: f32 = 100.0;
  function new (line 159) | pub fn new(program: P) -> Self {
  function width (line 172) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 178) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function tag (line 190) | fn tag(&self) -> tree::Tag {
  function state (line 195) | fn state(&self) -> tree::State {
  function size (line 199) | fn size(&self) -> Size<Length> {
  function layout (line 206) | fn layout(
  function update (line 215) | fn update(
  function mouse_interaction (line 260) | fn mouse_interaction(
  function draw (line 274) | fn draw(
  function from (line 310) | fn from(canvas: Canvas<P, Message, Theme, Renderer>) -> Element<'a, Mess...

FILE: widget/src/canvas/program.rs
  type Program (line 13) | pub trait Program<Message, Theme = crate::Theme, Renderer = crate::Rende...
    method update (line 32) | fn update(
    method draw (line 50) | fn draw(
    method mouse_interaction (line 65) | fn mouse_interaction(
  type State (line 80) | type State = T::State;
  function update (line 82) | fn update(
  function draw (line 92) | fn draw(
  function mouse_interaction (line 103) | fn mouse_interaction(

FILE: widget/src/checkbox.rs
  type Checkbox (line 82) | pub struct Checkbox<'a, Message, Theme = crate::Theme, Renderer = crate:...
  constant DEFAULT_SIZE (line 109) | const DEFAULT_SIZE: f32 = 16.0;
  function new (line 115) | pub fn new(is_checked: bool) -> Self {
  function label (line 141) | pub fn label(mut self, label: impl text::IntoFragment<'a>) -> Self {
  function on_toggle (line 151) | pub fn on_toggle<F>(mut self, f: F) -> Self
  function on_toggle_maybe (line 163) | pub fn on_toggle_maybe<F>(mut self, f: Option<F>) -> Self
  function size (line 172) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function width (line 178) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function spacing (line 184) | pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
  function text_size (line 190) | pub fn text_size(mut self, text_size: impl Into<Pixels>) -> Self {
  function line_height (line 196) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function shaping (line 202) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function wrapping (line 208) | pub fn wrapping(mut self, wrapping: text::Wrapping) -> Self {
  function font (line 216) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function icon (line 222) | pub fn icon(mut self, icon: Icon<Renderer::Font>) -> Self {
  function style (line 229) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 240) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 252) | fn tag(&self) -> tree::Tag {
  function state (line 256) | fn state(&self) -> tree::State {
  function size (line 260) | fn size(&self) -> Size<Length> {
  function layout (line 267) | fn layout(
  function update (line 312) | fn update(
  function mouse_interaction (line 359) | fn mouse_interaction(
  function draw (line 374) | fn draw(
  function operate (line 458) | fn operate(
  function from (line 478) | fn from(
  type Icon (line 487) | pub struct Icon<Font> {
  type Status (line 502) | pub enum Status {
  type Style (line 522) | pub struct Style {
  type Catalog (line 534) | pub trait Catalog: Sized {
    method default (line 539) | fn default<'a>() -> Self::Class<'a>;
    method style (line 542) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 551) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 553) | fn default<'a>() -> Self::Class<'a> {
    method style (line 557) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 548) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function primary (line 563) | pub fn primary(theme: &Theme, status: Status) -> Style {
  function secondary (line 592) | pub fn secondary(theme: &Theme, status: Status) -> Style {
  function success (line 621) | pub fn success(theme: &Theme, status: Status) -> Style {
  function danger (line 650) | pub fn danger(theme: &Theme, status: Status) -> Style {
  function styled (line 678) | fn styled(

FILE: widget/src/column.rs
  type Column (line 34) | pub struct Column<'a, Message, Theme = crate::Theme, Renderer = crate::R...
  function new (line 50) | pub fn new() -> Self {
  function with_capacity (line 55) | pub fn with_capacity(capacity: usize) -> Self {
  function with_children (line 60) | pub fn with_children(
  function from_vec (line 75) | pub fn from_vec(children: Vec<Element<'a, Message, Theme, Renderer>>) ->...
  function spacing (line 93) | pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function padding (line 99) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function width (line 105) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 111) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function max_width (line 117) | pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
  function align_x (line 123) | pub fn align_x(mut self, align: impl Into<alignment::Horizontal>) -> Self {
  function clip (line 130) | pub fn clip(mut self, clip: bool) -> Self {
  function push (line 136) | pub fn push(mut self, child: impl Into<Element<'a, Message, Theme, Rende...
  function extend (line 150) | pub fn extend(
  function wrap (line 160) | pub fn wrap(self) -> Wrapping<'a, Message, Theme, Renderer> {
  method default (line 173) | fn default() -> Self {
  function from_iter (line 181) | fn from_iter<T: IntoIterator<Item = Element<'a, Message, Theme, Renderer...
  function children (line 191) | fn children(&self) -> Vec<Tree> {
  function diff (line 195) | fn diff(&self, tree: &mut Tree) {
  function size (line 199) | fn size(&self) -> Size<Length> {
  function layout (line 206) | fn layout(
  function operate (line 228) | fn operate(
  function update (line 249) | fn update(
  function mouse_interaction (line 271) | fn mouse_interaction(
  function draw (line 292) | fn draw(
  function overlay (line 323) | fn overlay<'b>(
  function from (line 349) | fn from(column: Column<'a, Message, Theme, Renderer>) -> Self {
  type Wrapping (line 361) | pub struct Wrapping<'a, Message, Theme = crate::Theme, Renderer = crate:...
  function horizontal_spacing (line 369) | pub fn horizontal_spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function align_x (line 375) | pub fn align_x(mut self, align_y: impl Into<alignment::Vertical>) -> Self {
  function children (line 386) | fn children(&self) -> Vec<Tree> {
  function diff (line 390) | fn diff(&self, tree: &mut Tree) {
  function size (line 394) | fn size(&self) -> Size<Length> {
  function layout (line 398) | fn layout(
  function operate (line 510) | fn operate(
  function update (line 520) | fn update(
  function mouse_interaction (line 534) | fn mouse_interaction(
  function draw (line 546) | fn draw(
  function overlay (line 560) | fn overlay<'b>(
  function from (line 580) | fn from(column: Wrapping<'a, Message, Theme, Renderer>) -> Self {

FILE: widget/src/combo_box.rs
  type ComboBox (line 130) | pub struct ComboBox<'a, T, Message, Theme = crate::Theme, Renderer = cra...
  function new (line 161) | pub fn new(
  function on_input (line 194) | pub fn on_input(mut self, on_input: impl Fn(String) -> Message + 'a) -> ...
  function on_option_hovered (line 201) | pub fn on_option_hovered(mut self, on_option_hovered: impl Fn(T) -> Mess...
  function on_open (line 208) | pub fn on_open(mut self, message: Message) -> Self {
  function on_close (line 215) | pub fn on_close(mut self, message: Message) -> Self {
  function padding (line 221) | pub fn padding(mut self, padding: impl Into<Padding>) -> Self {
  function font (line 230) | pub fn font(mut self, font: Renderer::Font) -> Self {
  function icon (line 237) | pub fn icon(mut self, icon: text_input::Icon<Renderer::Font>) -> Self {
  function size (line 243) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 253) | pub fn line_height(self, line_height: impl Into<LineHeight>) -> Self {
  function width (line 261) | pub fn width(self, width: impl Into<Length>) -> Self {
  function menu_height (line 269) | pub fn menu_height(mut self, menu_height: impl Into<Length>) -> Self {
  function shaping (line 275) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function ellipsis (line 281) | pub fn ellipsis(mut self, ellipsis: text::Ellipsis) -> Self {
  function input_style (line 288) | pub fn input_style(
  function menu_style (line 301) | pub fn menu_style(mut self, style: impl Fn(&Theme) -> menu::Style + 'a) ...
  function input_class (line 312) | pub fn input_class(
  function menu_class (line 323) | pub fn menu_class(mut self, class: impl Into<<Theme as menu::Catalog>::C...
  type State (line 331) | pub struct State<T> {
  type Inner (line 337) | struct Inner<T> {
  type Filtered (line 344) | struct Filtered<T> {
  function new (line 354) | pub fn new(options: Vec<T>) -> Self {
  function with_selection (line 360) | pub fn with_selection(options: Vec<T>, selection: Option<&T>) -> Self {
  function options (line 386) | pub fn options(&self) -> &[T] {
  function push (line 391) | pub fn push(&mut self, new_option: T) {
  function into_options (line 405) | pub fn into_options(self) -> Vec<T> {
  function value (line 409) | fn value(&self) -> String {
  function with_inner (line 415) | fn with_inner<O>(&self, f: impl FnOnce(&Inner<T>) -> O) -> O {
  function with_inner_mut (line 421) | fn with_inner_mut(&self, f: impl FnOnce(&mut Inner<T>)) {
  function sync_filtered_options (line 427) | fn sync_filtered_options(&self, options: &mut Filtered<T>) {
  method default (line 438) | fn default() -> Self {
  function new (line 447) | fn new(options: Vec<T>) -> Self {
  function empty (line 454) | fn empty() -> Self {
  function update (line 461) | fn update(&mut self, options: Vec<T>) {
  function sync (line 466) | fn sync(&self, other: &mut Filtered<T>) {
  type Menu (line 473) | struct Menu<T> {
  type TextInputEvent (line 481) | enum TextInputEvent {
  function size (line 493) | fn size(&self) -> Size<Length> {
  function layout (line 497) | fn layout(
  function tag (line 519) | fn tag(&self) -> widget::tree::Tag {
  function state (line 523) | fn state(&self) -> widget::tree::State {
  function children (line 532) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 536) | fn diff(&self, _tree: &mut widget::Tree) {
  function update (line 540) | fn update(
  function mouse_interaction (line 759) | fn mouse_interaction(
  function draw (line 771) | fn draw(
  function overlay (line 806) | fn overlay<'b>(
  function from (line 892) | fn from(combo_box: ComboBox<'a, T, Message, Theme, Renderer>) -> Self {
  type Catalog (line 898) | pub trait Catalog: text_input::Catalog + menu::Catalog {
    method default_input (line 900) | fn default_input<'a>() -> <Self as text_input::Catalog>::Class<'a> {
    method default_menu (line 905) | fn default_menu<'a>() -> <Self as menu::Catalog>::Class<'a> {
  function search (line 912) | fn search<'a, T, A>(
  function build_matchers (line 939) | fn build_matchers<'a, T>(options: impl IntoIterator<Item = T> + 'a) -> V...
  function build_matcher (line 946) | fn build_matcher<T>(option: T) -> String

FILE: widget/src/container.rs
  type Container (line 58) | pub struct Container<'a, Message, Theme = crate::Theme, Renderer = crate...
  function new (line 82) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function id (line 102) | pub fn id(mut self, id: impl Into<widget::Id>) -> Self {
  function padding (line 108) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function width (line 114) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 120) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function max_width (line 126) | pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
  function max_height (line 132) | pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
  function center_x (line 138) | pub fn center_x(self, width: impl Into<Length>) -> Self {
  function center_y (line 143) | pub fn center_y(self, height: impl Into<Length>) -> Self {
  function center (line 154) | pub fn center(self, length: impl Into<Length>) -> Self {
  function align_left (line 161) | pub fn align_left(self, width: impl Into<Length>) -> Self {
  function align_right (line 166) | pub fn align_right(self, width: impl Into<Length>) -> Self {
  function align_top (line 171) | pub fn align_top(self, height: impl Into<Length>) -> Self {
  function align_bottom (line 176) | pub fn align_bottom(self, height: impl Into<Length>) -> Self {
  function align_x (line 181) | pub fn align_x(mut self, alignment: impl Into<alignment::Horizontal>) ->...
  function align_y (line 187) | pub fn align_y(mut self, alignment: impl Into<alignment::Vertical>) -> S...
  function clip (line 194) | pub fn clip(mut self, clip: bool) -> Self {
  function style (line 201) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 211) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 223) | fn tag(&self) -> tree::Tag {
  function state (line 227) | fn state(&self) -> tree::State {
  function children (line 231) | fn children(&self) -> Vec<Tree> {
  function diff (line 235) | fn diff(&self, tree: &mut Tree) {
  function size (line 239) | fn size(&self) -> Size<Length> {
  function layout (line 246) | fn layout(
  function operate (line 265) | fn operate(
  function update (line 283) | fn update(
  function mouse_interaction (line 304) | fn mouse_interaction(
  function draw (line 321) | fn draw(
  function overlay (line 355) | fn overlay<'b>(
  function from (line 380) | fn from(
  function layout (line 388) | pub fn layout(
  function draw_background (line 416) | pub fn draw_background<Renderer>(renderer: &mut Renderer, style: &Style,...
  type Style (line 437) | pub struct Style {
    method color (line 464) | pub fn color(self, color: impl Into<Color>) -> Self {
    method border (line 472) | pub fn border(self, border: impl Into<Border>) -> Self {
    method background (line 480) | pub fn background(self, background: impl Into<Background>) -> Self {
    method shadow (line 488) | pub fn shadow(self, shadow: impl Into<Shadow>) -> Self {
    method from (line 497) | fn from(color: Color) -> Self {
    method from (line 503) | fn from(gradient: Gradient) -> Self {
    method from (line 509) | fn from(gradient: gradient::Linear) -> Self {
  method default (line 451) | fn default() -> Self {
  type Catalog (line 515) | pub trait Catalog {
    method default (line 520) | fn default<'a>() -> Self::Class<'a>;
    method style (line 523) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 536) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 538) | fn default<'a>() -> Self::Class<'a> {
    method style (line 542) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 527) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function from (line 530) | fn from(style: Style) -> Self {
  function transparent (line 548) | pub fn transparent<Theme>(_theme: &Theme) -> Style {
  function background (line 553) | pub fn background(background: impl Into<Background>) -> Style {
  function rounded_box (line 558) | pub fn rounded_box(theme: &Theme) -> Style {
  function bordered_box (line 570) | pub fn bordered_box(theme: &Theme) -> Style {
  function dark (line 586) | pub fn dark(_theme: &Theme) -> Style {
  function primary (line 594) | pub fn primary(theme: &Theme) -> Style {
  function secondary (line 601) | pub fn secondary(theme: &Theme) -> Style {
  function success (line 608) | pub fn success(theme: &Theme) -> Style {
  function warning (line 615) | pub fn warning(theme: &Theme) -> Style {
  function danger (line 622) | pub fn danger(theme: &Theme) -> Style {
  function style (line 628) | fn style(pair: theme::palette::Pair) -> Style {

FILE: widget/src/float.rs
  type Float (line 15) | pub struct Float<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  function new (line 30) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function scale (line 40) | pub fn scale(mut self, scale: f32) -> Self {
  function translate (line 50) | pub fn translate(mut self, translate: impl Fn(Rectangle, Rectangle) -> V...
  function style (line 57) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 68) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function is_floating (line 73) | fn is_floating(&self, bounds: Rectangle, viewport: Rectangle) -> bool {
  function tag (line 88) | fn tag(&self) -> tree::Tag {
  function state (line 92) | fn state(&self) -> tree::State {
  function children (line 96) | fn children(&self) -> Vec<tree::Tree> {
  function diff (line 100) | fn diff(&self, tree: &mut widget::Tree) {
  function size (line 104) | fn size(&self) -> Size<Length> {
  function size_hint (line 108) | fn size_hint(&self) -> Size<Length> {
  function layout (line 112) | fn layout(
  function update (line 121) | fn update(
  function draw (line 140) | fn draw(
  function mouse_interaction (line 175) | fn mouse_interaction(
  function operate (line 192) | fn operate(
  function overlay (line 204) | fn overlay<'a>(
  function from (line 254) | fn from(float: Float<'a, Message, Theme, Renderer>) -> Self {
  type Overlay (line 259) | struct Overlay<'a, 'b, Message, Theme, Renderer>
  function layout (line 276) | fn layout(&mut self, _renderer: &Renderer, _bounds: Size) -> layout::Node {
  function update (line 282) | fn update(
  function draw (line 303) | fn draw(
  function mouse_interaction (line 345) | fn mouse_interaction(
  function index (line 366) | fn index(&self) -> f32 {
  function overlay (line 370) | fn overlay<'a>(
  type Catalog (line 389) | pub trait Catalog {
    method default (line 394) | fn default<'a>() -> Self::Class<'a>;
    method style (line 397) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 404) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 406) | fn default<'a>() -> Self::Class<'a> {
    method style (line 410) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 401) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  type Style (line 417) | pub struct Style {

FILE: widget/src/grid.rs
  type Grid (line 10) | pub struct Grid<'a, Message, Theme = crate::Theme, Renderer = crate::Ren...
  type Constraint (line 18) | enum Constraint {
  function new (line 28) | pub fn new() -> Self {
  function with_capacity (line 33) | pub fn with_capacity(capacity: usize) -> Self {
  function with_children (line 38) | pub fn with_children(
  function from_vec (line 47) | pub fn from_vec(children: Vec<Element<'a, Message, Theme, Renderer>>) ->...
  function spacing (line 58) | pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function width (line 68) | pub fn width(mut self, width: impl Into<Pixels>) -> Self {
  function height (line 76) | pub fn height(mut self, height: impl Into<Sizing>) -> Self {
  function columns (line 82) | pub fn columns(mut self, column: usize) -> Self {
  function fluid (line 89) | pub fn fluid(mut self, max_width: impl Into<Pixels>) -> Self {
  function push (line 95) | pub fn push(mut self, child: impl Into<Element<'a, Message, Theme, Rende...
  function push_maybe (line 101) | pub fn push_maybe(
  function extend (line 113) | pub fn extend(
  method default (line 125) | fn default() -> Self {
  function from_iter (line 133) | fn from_iter<T: IntoIterator<Item = Element<'a, Message, Theme, Renderer...
  function children (line 143) | fn children(&self) -> Vec<Tree> {
  function diff (line 147) | fn diff(&self, tree: &mut Tree) {
  function size (line 151) | fn size(&self) -> Size<Length> {
  function layout (line 164) | fn layout(
  function operate (line 243) | fn operate(
  function update (line 264) | fn update(
  function mouse_interaction (line 286) | fn mouse_interaction(
  function draw (line 307) | fn draw(
  function overlay (line 332) | fn overlay<'b>(
  function from (line 358) | fn from(row: Grid<'a, Message, Theme, Renderer>) -> Self {
  type Sizing (line 365) | pub enum Sizing {
    method from (line 379) | fn from(height: f32) -> Self {
    method from (line 385) | fn from(height: Length) -> Self {
  function aspect_ratio (line 391) | pub fn aspect_ratio(width: impl Into<Pixels>, height: impl Into<Pixels>)...

FILE: widget/src/helpers.rs
  function container (line 235) | pub fn container<'a, Message, Theme, Renderer>(
  function center (line 257) | pub fn center<'a, Message, Theme, Renderer>(
  function center_x (line 279) | pub fn center_x<'a, Message, Theme, Renderer>(
  function center_y (line 301) | pub fn center_y<'a, Message, Theme, Renderer>(
  function right (line 323) | pub fn right<'a, Message, Theme, Renderer>(
  function right_center (line 345) | pub fn right_center<'a, Message, Theme, Renderer>(
  function bottom (line 369) | pub fn bottom<'a, Message, Theme, Renderer>(
  function bottom_center (line 391) | pub fn bottom_center<'a, Message, Theme, Renderer>(
  function bottom_right (line 415) | pub fn bottom_right<'a, Message, Theme, Renderer>(
  function pin (line 450) | pub fn pin<'a, Message, Theme, Renderer>(
  function column (line 478) | pub fn column<'a, Message, Theme, Renderer>(
  function keyed_column (line 508) | pub fn keyed_column<'a, Key, Message, Theme, Renderer>(
  function row (line 537) | pub fn row<'a, Message, Theme, Renderer>(
  function grid (line 547) | pub fn grid<'a, Message, Theme, Renderer>(
  function stack (line 559) | pub fn stack<'a, Message, Theme, Renderer>(
  function opaque (line 575) | pub fn opaque<'a, Message, Theme, Renderer>(
  function hover (line 725) | pub fn hover<'a, Message, Theme, Renderer>(
  function sensor (line 986) | pub fn sensor<'a, Message, Theme, Renderer>(
  function scrollable (line 1018) | pub fn scrollable<'a, Message, Theme, Renderer>(
  function button (line 1046) | pub fn button<'a, Message, Theme, Renderer>(
  function tooltip (line 1082) | pub fn tooltip<'a, Message, Theme, Renderer>(
  function text (line 1115) | pub fn text<'a, Theme, Renderer>(text: impl text::IntoFragment<'a>) -> T...
  function value (line 1124) | pub fn value<'a, Theme, Renderer>(value: impl ToString) -> Text<'a, Them...
  function rich_text (line 1162) | pub fn rich_text<'a, Link, Message, Theme, Renderer>(
  function span (line 1206) | pub fn span<'a, Link, Font>(text: impl text::IntoFragment<'a>) -> text::...
  function checkbox (line 1247) | pub fn checkbox<'a, Message, Theme, Renderer>(
  function radio (line 1317) | pub fn radio<'a, Message, Theme, Renderer, V>(
  function toggler (line 1366) | pub fn toggler<'a, Message, Theme, Renderer>(
  function text_input (line 1410) | pub fn text_input<'a, Message, Theme, Renderer>(
  function text_editor (line 1457) | pub fn text_editor<'a, Message, Theme, Renderer>(
  function slider (line 1500) | pub fn slider<'a, T, Message, Theme>(
  function vertical_slider (line 1545) | pub fn vertical_slider<'a, T, Message, Theme>(
  function pick_list (line 1623) | pub fn pick_list<'a, T, L, V, Message, Theme, Renderer>(
  function combo_box (line 1697) | pub fn combo_box<'a, T, Message, Theme, Renderer>(
  function space (line 1715) | pub fn space() -> Space {
  function progress_bar (line 1746) | pub fn progress_bar<'a, Theme>(range: RangeInclusive<f32>, value: f32) -...
  function image (line 1776) | pub fn image<Handle>(handle: impl Into<Handle>) -> crate::Image<Handle> {
  function svg (line 1803) | pub fn svg<'a, Theme>(handle: impl Into<core::svg::Handle>) -> crate::Sv...
  function iced (line 1814) | pub fn iced<'a, Message, Theme, Renderer>(
  function canvas (line 1912) | pub fn canvas<P, Message, Theme, Renderer>(program: P) -> crate::Canvas<...
  function qr_code (line 1948) | pub fn qr_code<'a, Theme>(data: &'a crate::qr_code::Data) -> crate::QRCo...
  function shader (line 1959) | pub fn shader<Message, P>(program: P) -> crate::Shader<Message, P>
  function mouse_area (line 1967) | pub fn mouse_area<'a, Message, Theme, Renderer>(
  function themer (line 1977) | pub fn themer<'a, Message, Theme, Renderer>(
  function pane_grid (line 2025) | pub fn pane_grid<'a, T, Message, Theme, Renderer>(
  function float (line 2037) | pub fn float<'a, Message, Theme, Renderer>(
  function responsive (line 2053) | pub fn responsive<'a, Message, Theme, Renderer>(

FILE: widget/src/image.rs
  function viewer (line 35) | pub fn viewer<Handle>(handle: Handle) -> Viewer<Handle> {
  type Image (line 57) | pub struct Image<Handle = image::Handle> {
  function new (line 73) | pub fn new(handle: impl Into<Handle>) -> Self {
  function width (line 90) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 96) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function expand (line 109) | pub fn expand(mut self, expand: bool) -> Self {
  function content_fit (line 117) | pub fn content_fit(mut self, content_fit: ContentFit) -> Self {
  function filter_method (line 123) | pub fn filter_method(mut self, filter_method: FilterMethod) -> Self {
  function rotation (line 129) | pub fn rotation(mut self, rotation: impl Into<Rotation>) -> Self {
  function opacity (line 138) | pub fn opacity(mut self, opacity: impl Into<f32>) -> Self {
  function scale (line 147) | pub fn scale(mut self, scale: impl Into<f32>) -> Self {
  function crop (line 165) | pub fn crop(mut self, region: Rectangle<u32>) -> Self {
  function border_radius (line 174) | pub fn border_radius(mut self, border_radius: impl Into<border::Radius>)...
  function layout (line 181) | pub fn layout<Renderer, Handle>(
  function drawing_bounds (line 226) | fn drawing_bounds<Renderer, Handle>(
  function crop (line 295) | fn crop(size: Size<u32>, region: Option<Rectangle<u32>>) -> Size<f32> {
  function draw (line 307) | pub fn draw<Renderer, Handle>(
  function size (line 344) | fn size(&self) -> Size<Length> {
  function layout (line 351) | fn layout(
  function draw (line 370) | fn draw(
  function from (line 401) | fn from(image: Image<Handle>) -> Element<'a, Message, Theme, Renderer> {

FILE: widget/src/image/viewer.rs
  type Viewer (line 14) | pub struct Viewer<Handle> {
  function new (line 28) | pub fn new<T: Into<Handle>>(handle: T) -> Self {
  function filter_method (line 43) | pub fn filter_method(mut self, filter_method: image::FilterMethod) -> Se...
  function content_fit (line 49) | pub fn content_fit(mut self, content_fit: ContentFit) -> Self {
  function padding (line 55) | pub fn padding(mut self, padding: impl Into<Pixels>) -> Self {
  function width (line 61) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 67) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function max_scale (line 75) | pub fn max_scale(mut self, max_scale: f32) -> Self {
  function min_scale (line 83) | pub fn min_scale(mut self, min_scale: f32) -> Self {
  function scale_step (line 92) | pub fn scale_step(mut self, scale_step: f32) -> Self {
  function tag (line 103) | fn tag(&self) -> tree::Tag {
  function state (line 107) | fn state(&self) -> tree::State {
  function size (line 111) | fn size(&self) -> Size<Length> {
  function layout (line 118) | fn layout(
  function update (line 150) | fn update(
  function mouse_interaction (line 272) | fn mouse_interaction(
  function draw (line 293) | fn draw(
  type State (line 350) | pub struct State {
    method new (line 370) | pub fn new() -> Self {
    method offset (line 376) | fn offset(&self, bounds: Rectangle, image_size: Size) -> Vector {
    method is_cursor_grabbed (line 388) | pub fn is_cursor_grabbed(&self) -> bool {
  method default (line 358) | fn default() -> Self {
  function from (line 400) | fn from(viewer: Viewer<Handle>) -> Element<'a, Message, Theme, Renderer> {
  function scaled_image_size (line 408) | pub fn scaled_image_size<Renderer>(

FILE: widget/src/keyed/column.rs
  type Column (line 32) | pub struct Column<'a, Key, Message, Theme = crate::Theme, Renderer = cra...
  function new (line 52) | pub fn new() -> Self {
  function from_vecs (line 63) | pub fn from_vecs(keys: Vec<Key>, children: Vec<Element<'a, Message, Them...
  function with_capacity (line 77) | pub fn with_capacity(capacity: usize) -> Self {
  function with_children (line 82) | pub fn with_children(
  function spacing (line 95) | pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function padding (line 101) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function width (line 107) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 113) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function max_width (line 119) | pub fn max_width(mut self, max_width: impl Into<Pixels>) -> Self {
  function align_items (line 125) | pub fn align_items(mut self, align: Alignment) -> Self {
  function push (line 131) | pub fn push(
  function push_maybe (line 148) | pub fn push_maybe(
  function extend (line 161) | pub fn extend(
  method default (line 176) | fn default() -> Self {
  type State (line 181) | struct State<Key>
  function tag (line 194) | fn tag(&self) -> tree::Tag {
  function state (line 198) | fn state(&self) -> tree::State {
  function children (line 204) | fn children(&self) -> Vec<Tree> {
  function diff (line 208) | fn diff(&self, tree: &mut Tree) {
  function size (line 231) | fn size(&self) -> Size<Length> {
  function layout (line 238) | fn layout(
  function operate (line 263) | fn operate(
  function update (line 284) | fn update(
  function mouse_interaction (line 306) | fn mouse_interaction(
  function draw (line 327) | fn draw(
  function overlay (line 349) | fn overlay<'b>(
  function from (line 376) | fn from(column: Column<'a, Key, Message, Theme, Renderer>) -> Self {

FILE: widget/src/lazy.rs
  type Lazy (line 28) | pub struct Lazy<'a, Message, Theme, Renderer, Dependency, View> {
  function new (line 42) | pub fn new(dependency: Dependency, view: impl Fn(&Dependency) -> View + ...
  function with_element (line 50) | fn with_element<T>(&self, f: impl FnOnce(&Element<'_, Message, Theme, Re...
  function with_element_mut (line 61) | fn with_element_mut<T>(
  type Internal (line 76) | struct Internal<Message, Theme, Renderer> {
  function tag (line 90) | fn tag(&self) -> tree::Tag {
  function state (line 95) | fn state(&self) -> tree::State {
  function children (line 110) | fn children(&self) -> Vec<Tree> {
  function diff (line 114) | fn diff(&self, tree: &mut Tree) {
  function size (line 141) | fn size(&self) -> Size<Length> {
  function size_hint (line 145) | fn size_hint(&self) -> Size<Length> {
  function layout (line 152) | fn layout(
  function operate (line 165) | fn operate(
  function update (line 179) | fn update(
  function mouse_interaction (line 202) | fn mouse_interaction(
  function draw (line 221) | fn draw(
  function overlay (line 244) | fn overlay<'b>(
  type Inner (line 290) | struct Inner<'a, Message: 'a, Theme: 'a, Renderer: 'a> {
  type Overlay (line 301) | struct Overlay<'a, Message, Theme, Renderer>(Option<Inner<'a, Message, T...
  method drop (line 304) | fn drop(&mut self) {
  function with_overlay_maybe (line 311) | fn with_overlay_maybe<T>(
  function with_overlay_mut_maybe (line 321) | fn with_overlay_mut_maybe<T>(
  function layout (line 337) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function draw (line 342) | fn draw(
  function mouse_interaction (line 355) | fn mouse_interaction(
  function update (line 365) | fn update(
  function from (line 389) | fn from(lazy: Lazy<'a, Message, Theme, Renderer, Dependency, View>) -> S...

FILE: widget/src/lazy/cache.rs
  type Cache (line 8) | pub struct Cache<'a, Message: 'a, Theme: 'a, Renderer: 'a> {

FILE: widget/src/lazy/component.rs
  type Component (line 48) | pub trait Component<Message, Theme = crate::Theme, Renderer = crate::Ren...
    method update (line 58) | fn update(&mut self, state: &mut Self::State, event: Self::Event) -> O...
    method view (line 62) | fn view(&self, state: &Self::State) -> Element<'_, Self::Event, Theme,...
    method operate (line 67) | fn operate(
    method size_hint (line 79) | fn size_hint(&self) -> Size<Length> {
  type Tag (line 87) | struct Tag<T>(T);
  function view (line 91) | pub fn view<'a, C, Message, Theme, Renderer>(component: C) -> Element<'a...
  type Instance (line 113) | struct Instance<'a, Message, Theme, Renderer, Event, S> {
  type State (line 119) | struct State<'a, Message: 'a, Theme: 'a, Renderer: 'a, Event: 'a, S: 'a> {
  function diff_self (line 134) | fn diff_self(&self) {
  function rebuild_element_if_necessary (line 145) | fn rebuild_element_if_necessary(&self) {
  function rebuild_element_with_operation (line 177) | fn rebuild_element_with_operation(
  function with_element (line 220) | fn with_element<T>(&self, f: impl FnOnce(&Element<'_, Event, Theme, Rend...
  function with_element_mut (line 224) | fn with_element_mut<T>(
  function tag (line 243) | fn tag(&self) -> tree::Tag {
  function state (line 247) | fn state(&self) -> tree::State {
  function children (line 260) | fn children(&self) -> Vec<Tree> {
  function diff (line 264) | fn diff(&self, tree: &mut Tree) {
  function size (line 270) | fn size(&self) -> Size<Length> {
  function size_hint (line 274) | fn size_hint(&self) -> Size<Length> {
  function layout (line 283) | fn layout(
  function update (line 300) | fn update(
  function operate (line 362) | fn operate(
  function draw (line 382) | fn draw(
  function mouse_interaction (line 406) | fn mouse_interaction(
  function overlay (line 426) | fn overlay<'b>(
  type Overlay (line 485) | struct Overlay<'a, 'b, Message, Theme, Renderer, Event, S>(
  method drop (line 492) | fn drop(&mut self) {
  type Inner (line 500) | struct Inner<'a, 'b, Message, Theme, Renderer, Event, S> {
  type OverlayInstance (line 510) | struct OverlayInstance<'a, 'b, Message, Theme, Renderer, Event, S> {
  function with_overlay_maybe (line 517) | fn with_overlay_maybe<T>(
  function with_overlay_mut_maybe (line 530) | fn with_overlay_mut_maybe<T>(
  function layout (line 550) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function draw (line 555) | fn draw(
  function mouse_interaction (line 568) | fn mouse_interaction(
  function update (line 578) | fn update(

FILE: widget/src/lazy/helpers.rs
  function lazy (line 12) | pub fn lazy<'a, Message, Theme, Renderer, Dependency, View>(
  function component (line 32) | pub fn component<'a, C, Message, Theme, Renderer>(

FILE: widget/src/markdown.rs
  type Uri (line 68) | pub type Uri = String;
  type Content (line 72) | pub struct Content {
    method new (line 86) | pub fn new() -> Self {
    method parse (line 91) | pub fn parse(markdown: &str) -> Self {
    method push_str (line 101) | pub fn push_str(&mut self, markdown: &str) {
    method items (line 176) | pub fn items(&self) -> &[Item] {
    method images (line 181) | pub fn images(&self) -> &HashSet<Uri> {
  type Section (line 79) | struct Section {
  type Item (line 188) | pub enum Item {
  type Column (line 235) | pub struct Column {
  type Row (line 244) | pub struct Row {
  type Text (line 251) | pub struct Text {
    method new (line 258) | fn new(spans: Vec<Span>) -> Self {
    method spans (line 270) | pub fn spans(&self, style: Style) -> Arc<[text::Span<'static, Uri>]> {
  type Span (line 283) | enum Span {
    method view (line 301) | fn view(&self, style: &Style) -> text::Span<'static, Uri> {
  type Bullet (line 353) | pub enum Bullet {
    method items (line 369) | fn items(&self) -> &[Item] {
    method push (line 375) | fn push(&mut self, item: Item) {
  function parse (line 422) | pub fn parse(markdown: &str) -> impl Iterator<Item = Item> + '_ {
  type State (line 427) | struct State {
  type Highlighter (line 437) | struct Highlighter {
    method new (line 446) | pub fn new(language: &str) -> Self {
    method prepare (line 458) | pub fn prepare(&mut self) {
    method highlight_line (line 462) | pub fn highlight_line(&mut self, text: &str) -> &[Span] {
  function parse_with (line 512) | fn parse_with<'a>(
  type Settings (line 995) | pub struct Settings {
    method with_style (line 1020) | pub fn with_style(style: impl Into<Style>) -> Self {
    method with_text_size (line 1029) | pub fn with_text_size(text_size: impl Into<Pixels>, style: impl Into<S...
    method from (line 1048) | fn from(theme: &Theme) -> Self {
    method from (line 1054) | fn from(theme: Theme) -> Self {
  type Style (line 1061) | pub struct Style {
    method from_palette (line 1080) | pub fn from_palette(seed: palette::Seed) -> Self {
    method from (line 1097) | fn from(seed: palette::Seed) -> Self {
    method from (line 1103) | fn from(theme: &Theme) -> Self {
    method from (line 1109) | fn from(theme: Theme) -> Self {
  function view (line 1156) | pub fn view<'a, Theme, Renderer>(
  function view_with (line 1172) | pub fn view_with<'a, Message, Theme, Renderer>(
  function item (line 1193) | pub fn item<'a, Message, Theme, Renderer>(
  function heading (line 1228) | pub fn heading<'a, Message, Theme, Renderer>(
  function paragraph (line 1272) | pub fn paragraph<'a, Message, Theme, Renderer>(
  function unordered_list (line 1290) | pub fn unordered_list<'a, Message, Theme, Renderer>(
  function ordered_list (line 1332) | pub fn ordered_list<'a, Message, Theme, Renderer>(
  function code_block (line 1368) | pub fn code_block<'a, Message, Theme, Renderer>(
  function quote (line 1402) | pub fn quote<'a, Message, Theme, Renderer>(
  function rule (line 1428) | pub fn rule<'a, Message, Theme, Renderer>() -> Element<'a, Message, Them...
  function table (line 1438) | pub fn table<'a, Message, Theme, Renderer>(
  function items (line 1483) | pub fn items<'a, Message, Theme, Renderer>(
  type Viewer (line 1504) | pub trait Viewer<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
    method on_link_click (line 1512) | fn on_link_click(url: Uri) -> Message;
    method image (line 1517) | fn image(
    method heading (line 1536) | fn heading(
    method paragraph (line 1549) | fn paragraph(&self, settings: Settings, text: &Text) -> Element<'a, Me...
    method code_block (line 1556) | fn code_block(
    method unordered_list (line 1572) | fn unordered_list(
    method ordered_list (line 1583) | fn ordered_list(
    method quote (line 1595) | fn quote(
    method rule (line 1606) | fn rule(&self, _settings: Settings) -> Element<'a, Message, Theme, Ren...
    method table (line 1613) | fn table(
  type DefaultViewer (line 1624) | struct DefaultViewer;
    method on_link_click (line 1631) | fn on_link_click(url: Uri) -> Uri {
  type Catalog (line 1637) | pub trait Catalog:
    method code_block (line 1646) | fn code_block<'a>() -> <Self as container::Catalog>::Class<'a>;
    method code_block (line 1650) | fn code_block<'a>() -> <Self as container::Catalog>::Class<'a> {

FILE: widget/src/mouse_area.rs
  type MouseArea (line 11) | pub struct MouseArea<'a, Message, Theme = crate::Theme, Renderer = crate...
  function on_press (line 30) | pub fn on_press(mut self, message: Message) -> Self {
  function on_release (line 37) | pub fn on_release(mut self, message: Message) -> Self {
  function on_double_click (line 53) | pub fn on_double_click(mut self, message: Message) -> Self {
  function on_right_press (line 60) | pub fn on_right_press(mut self, message: Message) -> Self {
  function on_right_release (line 67) | pub fn on_right_release(mut self, message: Message) -> Self {
  function on_middle_press (line 74) | pub fn on_middle_press(mut self, message: Message) -> Self {
  function on_middle_release (line 81) | pub fn on_middle_release(mut self, message: Message) -> Self {
  function on_scroll (line 88) | pub fn on_scroll(mut self, on_scroll: impl Fn(mouse::ScrollDelta) -> Mes...
  function on_enter (line 95) | pub fn on_enter(mut self, message: Message) -> Self {
  function on_move (line 102) | pub fn on_move(mut self, on_move: impl Fn(Point) -> Message + 'a) -> Self {
  function on_exit (line 109) | pub fn on_exit(mut self, message: Message) -> Self {
  function interaction (line 116) | pub fn interaction(mut self, interaction: mouse::Interaction) -> Self {
  type State (line 124) | struct State {
  function new (line 133) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function tag (line 158) | fn tag(&self) -> tree::Tag {
  function state (line 162) | fn state(&self) -> tree::State {
  function children (line 166) | fn children(&self) -> Vec<Tree> {
  function diff (line 170) | fn diff(&self, tree: &mut Tree) {
  function size (line 174) | fn size(&self) -> Size<Length> {
  function layout (line 178) | fn layout(
  function operate (line 189) | fn operate(
  function update (line 201) | fn update(
  function mouse_interaction (line 228) | fn mouse_interaction(
  function draw (line 252) | fn draw(
  function overlay (line 273) | fn overlay<'b>(
  function from (line 298) | fn from(
  function update (line 307) | fn update<Message: Clone, Theme, Renderer>(

FILE: widget/src/overlay/menu.rs
  type Menu (line 20) | pub struct Menu<'a, 'b, T, Message, Theme = crate::Theme, Renderer = cra...
  function new (line 52) | pub fn new(
  function width (line 80) | pub fn width(mut self, width: f32) -> Self {
  function padding (line 86) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function text_size (line 92) | pub fn text_size(mut self, text_size: impl Into<Pixels>) -> Self {
  function line_height (line 98) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function shaping (line 104) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function ellipsis (line 110) | pub fn ellipsis(mut self, ellipsis: text::Ellipsis) -> Self {
  function font (line 116) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function overlay (line 127) | pub fn overlay(
  type State (line 146) | pub struct State {
    method new (line 152) | pub fn new() -> Self {
  method default (line 160) | fn default() -> Self {
  type Overlay (line 165) | struct Overlay<'a, 'b, Message, Theme, Renderer>
  function new (line 186) | pub fn new<T>(
  function layout (line 249) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function update (line 276) | fn update(
  function mouse_interaction (line 290) | fn mouse_interaction(
  function draw (line 300) | fn draw(
  type List (line 328) | struct List<'a, 'b, T, Message, Theme, Renderer>
  type ListState (line 347) | struct ListState {
  function tag (line 358) | fn tag(&self) -> tree::Tag {
  function state (line 362) | fn state(&self) -> tree::State {
  function size (line 366) | fn size(&self) -> Size<Length> {
  function layout (line 373) | fn layout(
  function update (line 397) | fn update(
  function mouse_interaction (line 471) | fn mouse_interaction(
  function draw (line 488) | fn draw(
  function from (line 571) | fn from(list: List<'a, 'b, T, Message, Theme, Renderer>) -> Self {
  type Style (line 578) | pub struct Style {
  type Catalog (line 594) | pub trait Catalog: scrollable::Catalog {
    method default (line 599) | fn default<'a>() -> <Self as Catalog>::Class<'a>;
    method default_scrollable (line 602) | fn default_scrollable<'a>() -> <Self as scrollable::Catalog>::Class<'a> {
    method style (line 607) | fn style(&self, class: &<Self as Catalog>::Class<'_>) -> Style;
    type Class (line 614) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 616) | fn default<'a>() -> StyleFn<'a, Self> {
    method style (line 620) | fn style(&self, class: &StyleFn<'_, Self>) -> Style {
  type StyleFn (line 611) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function default (line 626) | pub fn default(theme: &Theme) -> Style {

FILE: widget/src/pane_grid.rs
  constant DRAG_DEADBAND_DISTANCE (line 95) | const DRAG_DEADBAND_DISTANCE: f32 = 10.0;
  constant THICKNESS_RATIO (line 96) | const THICKNESS_RATIO: f32 = 25.0;
  type PaneGrid (line 150) | pub struct PaneGrid<'a, Message, Theme = crate::Theme, Renderer = crate:...
  function new (line 178) | pub fn new<T>(
  function width (line 209) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 215) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function spacing (line 221) | pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function min_size (line 227) | pub fn min_size(mut self, min_size: impl Into<Pixels>) -> Self {
  function on_click (line 234) | pub fn on_click<F>(mut self, f: F) -> Self
  function on_drag (line 244) | pub fn on_drag<F>(mut self, f: F) -> Self
  function on_resize (line 263) | pub fn on_resize<F>(mut self, leeway: impl Into<Pixels>, f: F) -> Self
  function style (line 275) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 286) | pub fn class(mut self, class: impl Into<<Theme as Catalog>::Class<'a>>) ...
  function drag_enabled (line 291) | fn drag_enabled(&self) -> bool {
  function grid_interaction (line 299) | fn grid_interaction(
  type Memory (line 339) | struct Memory {
  function tag (line 350) | fn tag(&self) -> tree::Tag {
  function state (line 354) | fn state(&self) -> tree::State {
  function children (line 358) | fn children(&self) -> Vec<Tree> {
  function diff (line 362) | fn diff(&self, tree: &mut Tree) {
  function size (line 394) | fn size(&self) -> Size<Length> {
  function layout (line 401) | fn layout(
  function operate (line 439) | fn operate(
  function update (line 464) | fn update(
  function mouse_interaction (line 669) | fn mouse_interaction(
  function draw (line 708) | fn draw(
  function overlay (line 909) | fn overlay<'b>(
  function from (line 948) | fn from(
  function layout_region (line 955) | fn layout_region(layout: Layout<'_>, cursor_position: Point) -> Option<R...
  function click_pane (line 977) | fn click_pane<'a, Message, T>(
  function in_edge (line 1010) | fn in_edge(layout: Layout<'_>, cursor: Point) -> Option<Edge> {
  function edge_bounds (line 1031) | fn edge_bounds(layout: Layout<'_>, edge: Edge) -> Rectangle {
  function layout_region_bounds (line 1060) | fn layout_region_bounds(layout: Layout<'_>, region: Region) -> Rectangle {
  type DragEvent (line 1090) | pub enum DragEvent {
  type Target (line 1116) | pub enum Target {
  type Region (line 1125) | pub enum Region {
  type Edge (line 1135) | pub enum Edge {
  type ResizeEvent (line 1148) | pub struct ResizeEvent {
  function hovered_split (line 1162) | fn hovered_split<'a>(
  type Style (line 1180) | pub struct Style {
  type Highlight (line 1191) | pub struct Highlight {
  type Line (line 1202) | pub struct Line {
  type Catalog (line 1210) | pub trait Catalog: container::Catalog {
    method default (line 1215) | fn default<'a>() -> <Self as Catalog>::Class<'a>;
    method style (line 1218) | fn style(&self, class: &<Self as Catalog>::Class<'_>) -> Style;
    type Class (line 1227) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 1229) | fn default<'a>() -> StyleFn<'a, Self> {
    method style (line 1233) | fn style(&self, class: &StyleFn<'_, Self>) -> Style {
  type StyleFn (line 1224) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function default (line 1239) | pub fn default(theme: &Theme) -> Style {

FILE: widget/src/pane_grid/axis.rs
  type Axis (line 5) | pub enum Axis {
    method split (line 15) | pub fn split(
    method split_line_bounds (line 74) | pub fn split_line_bounds(&self, rectangle: Rectangle, ratio: f32, spac...
  type Case (line 96) | enum Case {
  function split (line 114) | fn split() {

FILE: widget/src/pane_grid/configuration.rs
  type Configuration (line 7) | pub enum Configuration<T> {

FILE: widget/src/pane_grid/content.rs
  type Content (line 13) | pub struct Content<'a, Message, Theme = crate::Theme, Renderer = crate::...
  function new (line 29) | pub fn new(body: impl Into<Element<'a, Message, Theme, Renderer>>) -> Se...
  function title_bar (line 38) | pub fn title_bar(mut self, title_bar: TitleBar<'a, Message, Theme, Rende...
  function style (line 45) | pub fn style(mut self, style: impl Fn(&Theme) -> container::Style + 'a) ...
  function class (line 56) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function state (line 67) | pub(super) fn state(&self) -> Tree {
  function diff (line 80) | pub(super) fn diff(&self, tree: &mut Tree) {
  function draw (line 95) | pub fn draw(
  function layout (line 153) | pub(crate) fn layout(
  function operate (line 193) | pub(crate) fn operate(
  function update (line 220) | pub(crate) fn update(
  function grid_interaction (line 262) | pub(crate) fn grid_interaction(
  function mouse_interaction (line 285) | pub(crate) fn mouse_interaction(
  function overlay (line 328) | pub(crate) fn overlay<'b>(
  method can_be_dragged_at (line 377) | fn can_be_dragged_at(&self, layout: Layout<'_>, cursor_position: Point) ...
  function from (line 395) | fn from(element: T) -> Self {

FILE: widget/src/pane_grid/controls.rs
  type Controls (line 7) | pub struct Controls<'a, Message, Theme = crate::Theme, Renderer = crate:...
  function new (line 22) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function dynamic (line 32) | pub fn dynamic(
  function from (line 49) | fn from(value: Element<'a, Message, Theme, Renderer>) -> Self {

FILE: widget/src/pane_grid/direction.rs
  type Direction (line 3) | pub enum Direction {

FILE: widget/src/pane_grid/draggable.rs
  type Draggable (line 4) | pub trait Draggable {
    method can_be_dragged_at (line 7) | fn can_be_dragged_at(&self, layout: Layout<'_>, cursor: Point) -> bool;

FILE: widget/src/pane_grid/node.rs
  type Node (line 10) | pub enum Node {
    method splits (line 61) | pub fn splits(&self) -> impl Iterator<Item = &Split> {
    method count (line 78) | fn count(&self) -> Count {
    method pane_regions (line 108) | pub fn pane_regions(
    method split_regions (line 136) | pub fn split_regions(
    method find (line 161) | pub(crate) fn find(&mut self, pane: Pane) -> Option<&mut Node> {
    method split (line 174) | pub(crate) fn split(&mut self, id: Split, axis: Axis, new_pane: Pane) {
    method split_inverse (line 184) | pub(crate) fn split_inverse(&mut self, id: Split, axis: Axis, pane: Pa...
    method update (line 194) | pub(crate) fn update(&mut self, f: &impl Fn(&mut Node)) {
    method resize (line 203) | pub(crate) fn resize(&mut self, split: Split, percentage: f32) -> bool {
    method remove (line 222) | pub(crate) fn remove(&mut self, pane: Pane) -> Option<Pane> {
    method pane (line 239) | fn pane(&self) -> Option<Pane> {
    method first_pane (line 246) | fn first_pane(&self) -> Pane {
    method compute_regions (line 253) | fn compute_regions(
    method compute_splits (line 297) | fn compute_splits(
    method hash (line 347) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  type Count (line 33) | enum Count {
    method horizontal (line 44) | fn horizontal(&self) -> usize {
    method vertical (line 51) | fn vertical(&self) -> usize {

FILE: widget/src/pane_grid/pane.rs
  type Pane (line 5) | pub struct Pane(pub(super) usize);

FILE: widget/src/pane_grid/split.rs
  type Split (line 5) | pub struct Split(pub(super) usize);

FILE: widget/src/pane_grid/state.rs
  type State (line 23) | pub struct State<T> {
  function new (line 40) | pub fn new(first_pane_state: T) -> (Self, Pane) {
  function with_configuration (line 48) | pub fn with_configuration(config: impl Into<Configuration<T>>) -> Self {
  function len (line 57) | pub fn len(&self) -> usize {
  function is_empty (line 62) | pub fn is_empty(&self) -> bool {
  function get (line 67) | pub fn get(&self, pane: Pane) -> Option<&T> {
  function get_mut (line 73) | pub fn get_mut(&mut self, pane: Pane) -> Option<&mut T> {
  function iter (line 79) | pub fn iter(&self) -> impl Iterator<Item = (&Pane, &T)> {
  function iter_mut (line 85) | pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Pane, &mut T)> {
  function layout (line 90) | pub fn layout(&self) -> &Node {
  function adjacent (line 96) | pub fn adjacent(&self, pane: Pane, direction: Direction) -> Option<Pane> {
  function split (line 126) | pub fn split(&mut self, axis: Axis, pane: Pane, state: T) -> Option<(Pan...
  function split_with (line 133) | pub fn split_with(&mut self, target: Pane, pane: Pane, region: Region) {
  function drop (line 154) | pub fn drop(&mut self, pane: Pane, target: Target) {
  function split_node (line 163) | fn split_node(
  function split_and_swap (line 201) | fn split_and_swap(&mut self, axis: Axis, target: Pane, pane: Pane, swap:...
  function move_to_edge (line 217) | pub fn move_to_edge(&mut self, pane: Pane, edge: Edge) {
  function split_major_node_and_swap (line 234) | fn split_major_node_and_swap(&mut self, axis: Axis, pane: Pane, inverse:...
  function relabel (line 243) | fn relabel(&mut self, target: Pane, label: Pane) {
  function swap (line 259) | pub fn swap(&mut self, a: Pane, b: Pane) {
  function resize (line 282) | pub fn resize(&mut self, split: Split, ratio: f32) {
  function close (line 288) | pub fn close(&mut self, pane: Pane) -> Option<(T, Pane)> {
  function maximize (line 304) | pub fn maximize(&mut self, pane: Pane) {
  function restore (line 312) | pub fn restore(&mut self) {
  function maximized (line 319) | pub fn maximized(&self) -> Option<Pane> {
  type Internal (line 328) | pub struct Internal {
    method from_configuration (line 339) | pub fn from_configuration<T>(
    method layout (line 384) | pub(super) fn layout(&self) -> Cow<'_, Node> {
    method maximized (line 391) | pub(super) fn maximized(&self) -> Option<Pane> {
  type Action (line 400) | pub enum Action {
    method picked_pane (line 428) | pub fn picked_pane(&self) -> Option<(Pane, Point)> {
    method picked_split (line 436) | pub fn picked_split(&self) -> Option<(Split, Axis)> {

FILE: widget/src/pane_grid/title_bar.rs
  type TitleBar (line 13) | pub struct TitleBar<'a, Message, Theme = crate::Theme, Renderer = crate:...
  function new (line 31) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function controls (line 42) | pub fn controls(mut self, controls: impl Into<Controls<'a, Message, Them...
  function padding (line 48) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function always_show_controls (line 61) | pub fn always_show_controls(mut self) -> Self {
  function style (line 68) | pub fn style(mut self, style: impl Fn(&Theme) -> container::Style + 'a) ...
  function class (line 79) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function state (line 90) | pub(super) fn state(&self) -> Tree {
  function diff (line 115) | pub(super) fn diff(&self, tree: &mut Tree) {
  function draw (line 134) | pub fn draw(
  function is_over_pick_area (line 222) | pub fn is_over_pick_area(&self, layout: Layout<'_>, cursor_position: Poi...
  function layout (line 255) | pub(crate) fn layout(
  function operate (line 338) | pub(crate) fn operate(
  function update (line 396) | pub(crate) fn update(
  function mouse_interaction (line 469) | pub(crate) fn mouse_interaction(
  function overlay (line 525) | pub(crate) fn overlay<'b>(

FILE: widget/src/pick_list.rs
  type PickList (line 147) | pub struct PickList<'a, T, L, V, Message, Theme = crate::Theme, Renderer...
  function new (line 187) | pub fn new(selected: Option<V>, options: L, to_string: impl Fn(&T) -> St...
  function placeholder (line 212) | pub fn placeholder(mut self, placeholder: impl Into<String>) -> Self {
  function width (line 218) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function menu_height (line 224) | pub fn menu_height(mut self, menu_height: impl Into<Length>) -> Self {
  function padding (line 230) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function text_size (line 236) | pub fn text_size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 242) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function shaping (line 248) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function ellipsis (line 254) | pub fn ellipsis(mut self, ellipsis: text::Ellipsis) -> Self {
  function font (line 260) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function handle (line 266) | pub fn handle(mut self, handle: Handle<Renderer::Font>) -> Self {
  function on_select (line 272) | pub fn on_select(mut self, on_select: impl Fn(T) -> Message + 'a) -> Self {
  function on_open (line 278) | pub fn on_open(mut self, on_open: Message) -> Self {
  function on_close (line 284) | pub fn on_close(mut self, on_close: Message) -> Self {
  function style (line 291) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function menu_style (line 301) | pub fn menu_style(mut self, style: impl Fn(&Theme) -> menu::Style + 'a) ...
  function class (line 312) | pub fn class(mut self, class: impl Into<<Theme as Catalog>::Class<'a>>) ...
  function menu_class (line 320) | pub fn menu_class(mut self, class: impl Into<<Theme as menu::Catalog>::C...
  function tag (line 336) | fn tag(&self) -> tree::Tag {
  function state (line 340) | fn state(&self) -> tree::State {
  function size (line 344) | fn size(&self) -> Size<Length> {
  function layout (line 351) | fn layout(
  function update (line 430) | fn update(
  function mouse_interaction (line 548) | fn mouse_interaction(
  function draw (line 570) | fn draw(
  function overlay (line 697) | fn overlay<'b>(
  function from (line 760) | fn from(pick_list: PickList<'a, T, L, V, Message, Theme, Renderer>) -> S...
  type State (line 766) | struct State<P: text::Paragraph> {
  function new (line 777) | fn new() -> Self {
  method default (line 790) | fn default() -> Self {
  type Handle (line 797) | pub enum Handle<Font> {
  method default (line 819) | fn default() -> Self {
  type Icon (line 826) | pub struct Icon<Font> {
  type Status (line 841) | pub enum Status {
  type Style (line 857) | pub struct Style {
  type Catalog (line 871) | pub trait Catalog: menu::Catalog {
    method default (line 876) | fn default<'a>() -> <Self as Catalog>::Class<'a>;
    method default_menu (line 879) | fn default_menu<'a>() -> <Self as menu::Catalog>::Class<'a> {
    method style (line 884) | fn style(&self, class: &<Self as Catalog>::Class<'_>, status: Status) ...
    type Class (line 893) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 895) | fn default<'a>() -> StyleFn<'a, Self> {
    method style (line 899) | fn style(&self, class: &StyleFn<'_, Self>, status: Status) -> Style {
  type StyleFn (line 890) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 905) | pub fn default(theme: &Theme, status: Status) -> Style {

FILE: widget/src/pin.rs
  type Pin (line 54) | pub struct Pin<'a, Message, Theme = crate::Theme, Renderer = crate::Rend...
  function new (line 69) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function width (line 79) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 85) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function position (line 91) | pub fn position(mut self, position: impl Into<Point>) -> Self {
  function x (line 97) | pub fn x(mut self, x: impl Into<Pixels>) -> Self {
  function y (line 103) | pub fn y(mut self, y: impl Into<Pixels>) -> Self {
  function tag (line 114) | fn tag(&self) -> widget::tree::Tag {
  function state (line 118) | fn state(&self) -> widget::tree::State {
  function children (line 122) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 126) | fn diff(&self, tree: &mut widget::Tree) {
  function size (line 130) | fn size(&self) -> Size<Length> {
  function layout (line 137) | fn layout(
  function operate (line 157) | fn operate(
  function update (line 172) | fn update(
  function mouse_interaction (line 193) | fn mouse_interaction(
  function draw (line 210) | fn draw(
  function overlay (line 235) | fn overlay<'b>(
  function from (line 260) | fn from(pin: Pin<'a, Message, Theme, Renderer>) -> Element<'a, Message, ...

FILE: widget/src/progress_bar.rs
  type ProgressBar (line 54) | pub struct ProgressBar<'a, Theme = crate::Theme>
  constant DEFAULT_GIRTH (line 71) | pub const DEFAULT_GIRTH: f32 = 30.0;
  function new (line 78) | pub fn new(range: RangeInclusive<f32>, value: f32) -> Self {
  function length (line 90) | pub fn length(mut self, length: impl Into<Length>) -> Self {
  function girth (line 96) | pub fn girth(mut self, girth: impl Into<Length>) -> Self {
  function vertical (line 104) | pub fn vertical(mut self) -> Self {
  function style (line 111) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 122) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function width (line 127) | fn width(&self) -> Length {
  function height (line 135) | fn height(&self) -> Length {
  function size (line 149) | fn size(&self) -> Size<Length> {
  function layout (line 156) | fn layout(
  function draw (line 165) | fn draw(
  function from (line 237) | fn from(progress_bar: ProgressBar<'a, Theme>) -> Element<'a, Message, Th...
  type Style (line 244) | pub struct Style {
  type Catalog (line 254) | pub trait Catalog: Sized {
    method default (line 259) | fn default<'a>() -> Self::Class<'a>;
    method style (line 262) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 271) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 273) | fn default<'a>() -> Self::Class<'a> {
    method style (line 277) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 268) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function primary (line 283) | pub fn primary(theme: &Theme) -> Style {
  function secondary (line 290) | pub fn secondary(theme: &Theme) -> Style {
  function success (line 300) | pub fn success(theme: &Theme) -> Style {
  function warning (line 307) | pub fn warning(theme: &Theme) -> Style {
  function danger (line 314) | pub fn danger(theme: &Theme) -> Style {
  function styled (line 320) | fn styled(background: impl Into<Background>, bar: impl Into<Background>)...

FILE: widget/src/qr_code.rs
  constant DEFAULT_CELL_SIZE (line 36) | const DEFAULT_CELL_SIZE: f32 = 4.0;
  constant QUIET_ZONE (line 37) | const QUIET_ZONE: usize = 2;
  type QRCode (line 62) | pub struct QRCode<'a, Theme = crate::Theme>
  function new (line 76) | pub fn new(data: &'a Data) -> Self {
  function cell_size (line 85) | pub fn cell_size(mut self, cell_size: impl Into<Pixels>) -> Self {
  function total_size (line 91) | pub fn total_size(mut self, total_size: impl Into<Pixels>) -> Self {
  function style (line 99) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 110) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 120) | fn tag(&self) -> tree::Tag {
  function state (line 124) | fn state(&self) -> tree::State {
  function size (line 128) | fn size(&self) -> Size<Length> {
  function layout (line 135) | fn layout(
  function draw (line 146) | fn draw(
  function from (line 215) | fn from(qr_code: QRCode<'a, Theme>) -> Self {
  type Data (line 224) | pub struct Data {
    method new (line 235) | pub fn new(data: impl AsRef<[u8]>) -> Result<Self, Error> {
    method with_error_correction (line 242) | pub fn with_error_correction(
    method with_version (line 253) | pub fn with_version(
    method build (line 263) | fn build(encoded: qrcode::QrCode) -> Self {
  type Version (line 280) | pub enum Version {
  function from (line 289) | fn from(version: Version) -> Self {
  type ErrorCorrection (line 304) | pub enum ErrorCorrection {
  function from (line 316) | fn from(ec_level: ErrorCorrection) -> Self {
  type Error (line 328) | pub enum Error {
    method from (line 359) | fn from(error: qrcode::types::QrError) -> Self {
  type State (line 373) | struct State {
  type Style (line 379) | pub struct Style {
  type Catalog (line 387) | pub trait Catalog {
    method default (line 392) | fn default<'a>() -> Self::Class<'a>;
    method style (line 395) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 402) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 404) | fn default<'a>() -> Self::Class<'a> {
    method style (line 408) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 399) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function default (line 414) | pub fn default(theme: &Theme) -> Style {

FILE: widget/src/radio.rs
  type Radio (line 132) | pub struct Radio<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  constant DEFAULT_SIZE (line 159) | pub const DEFAULT_SIZE: f32 = 16.0;
  constant DEFAULT_SPACING (line 162) | pub const DEFAULT_SPACING: f32 = 8.0;
  function new (line 172) | pub fn new<F, V>(label: impl Into<String>, value: V, selected: Option<V>...
  function size (line 195) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function width (line 201) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function spacing (line 207) | pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
  function text_size (line 213) | pub fn text_size(mut self, text_size: impl Into<Pixels>) -> Self {
  function line_height (line 219) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function shaping (line 225) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function wrapping (line 231) | pub fn wrapping(mut self, wrapping: text::Wrapping) -> Self {
  function font (line 237) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function style (line 244) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 255) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 268) | fn tag(&self) -> tree::Tag {
  function state (line 272) | fn state(&self) -> tree::State {
  function size (line 276) | fn size(&self) -> Size<Length> {
  function layout (line 283) | fn layout(
  function update (line 320) | fn update(
  function mouse_interaction (line 362) | fn mouse_interaction(
  function draw (line 377) | fn draw(
  function from (line 458) | fn from(radio: Radio<'a, Message, Theme, Renderer>) -> Element<'a, Messa...
  type Status (line 465) | pub enum Status {
  type Style (line 480) | pub struct Style {
  type Catalog (line 494) | pub trait Catalog {
    method default (line 499) | fn default<'a>() -> Self::Class<'a>;
    method style (line 502) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 509) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 511) | fn default<'a>() -> Self::Class<'a> {
    method style (line 515) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 506) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 521) | pub fn default(theme: &Theme, status: Status) -> Style {

FILE: widget/src/responsive.rs
  type Responsive (line 14) | pub struct Responsive<'a, Message, Theme = crate::Theme, Renderer = crat...
  function new (line 31) | pub fn new(view: impl Fn(Size) -> Element<'a, Message, Theme, Renderer> ...
  function width (line 41) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 47) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function diff (line 58) | fn diff(&self, _tree: &mut Tree) {
  function size (line 62) | fn size(&self) -> Size<Length> {
  function layout (line 69) | fn layout(
  function update (line 91) | fn update(
  function draw (line 112) | fn draw(
  function mouse_interaction (line 133) | fn mouse_interaction(
  function operate (line 150) | fn operate(
  function overlay (line 165) | fn overlay<'a>(
  function from (line 190) | fn from(responsive: Responsive<'a, Message, Theme, Renderer>) -> Self {

FILE: widget/src/row.rs
  type Row (line 34) | pub struct Row<'a, Message, Theme = crate::Theme, Renderer = crate::Rend...
  function new (line 49) | pub fn new() -> Self {
  function with_capacity (line 54) | pub fn with_capacity(capacity: usize) -> Self {
  function with_children (line 59) | pub fn with_children(
  function from_vec (line 74) | pub fn from_vec(children: Vec<Element<'a, Message, Theme, Renderer>>) ->...
  function spacing (line 91) | pub fn spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function padding (line 97) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function width (line 103) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 109) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function align_y (line 115) | pub fn align_y(mut self, align: impl Into<alignment::Vertical>) -> Self {
  function clip (line 122) | pub fn clip(mut self, clip: bool) -> Self {
  function push (line 128) | pub fn push(mut self, child: impl Into<Element<'a, Message, Theme, Rende...
  function extend (line 142) | pub fn extend(
  function wrap (line 152) | pub fn wrap(self) -> Wrapping<'a, Message, Theme, Renderer> {
  method default (line 165) | fn default() -> Self {
  function from_iter (line 173) | fn from_iter<T: IntoIterator<Item = Element<'a, Message, Theme, Renderer...
  function children (line 183) | fn children(&self) -> Vec<Tree> {
  function diff (line 187) | fn diff(&self, tree: &mut Tree) {
  function size (line 191) | fn size(&self) -> Size<Length> {
  function layout (line 198) | fn layout(
  function operate (line 218) | fn operate(
  function update (line 239) | fn update(
  function mouse_interaction (line 261) | fn mouse_interaction(
  function draw (line 282) | fn draw(
  function overlay (line 313) | fn overlay<'b>(
  function from (line 339) | fn from(row: Row<'a, Message, Theme, Renderer>) -> Self {
  type Wrapping (line 350) | pub struct Wrapping<'a, Message, Theme = crate::Theme, Renderer = crate:...
  function vertical_spacing (line 358) | pub fn vertical_spacing(mut self, amount: impl Into<Pixels>) -> Self {
  function align_x (line 364) | pub fn align_x(mut self, align_x: impl Into<alignment::Horizontal>) -> S...
  function children (line 375) | fn children(&self) -> Vec<Tree> {
  function diff (line 379) | fn diff(&self, tree: &mut Tree) {
  function size (line 383) | fn size(&self) -> Size<Length> {
  function layout (line 387) | fn layout(
  function operate (line 497) | fn operate(
  function update (line 507) | fn update(
  function mouse_interaction (line 521) | fn mouse_interaction(
  function draw (line 533) | fn draw(
  function overlay (line 547) | fn overlay<'b>(
  function from (line 567) | fn from(row: Wrapping<'a, Message, Theme, Renderer>) -> Self {

FILE: widget/src/rule.rs
  function horizontal (line 28) | pub fn horizontal<'a, Theme>(height: impl Into<Pixels>) -> Rule<'a, Theme>
  function vertical (line 40) | pub fn vertical<'a, Theme>(width: impl Into<Pixels>) -> Rule<'a, Theme>
  type Rule (line 69) | pub struct Rule<'a, Theme = crate::Theme>
  function style (line 84) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function class (line 95) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function size (line 106) | fn size(&self) -> Size<Length> {
  function layout (line 120) | fn layout(
  function draw (line 131) | fn draw(
  function from (line 195) | fn from(rule: Rule<'a, Theme>) -> Element<'a, Message, Theme, Renderer> {
  type Style (line 202) | pub struct Style {
  type FillMode (line 215) | pub enum FillMode {
    method fill (line 238) | pub fn fill(&self, space: f32) -> (f32, f32) {
  type Catalog (line 278) | pub trait Catalog: Sized {
    method default (line 283) | fn default<'a>() -> Self::Class<'a>;
    method style (line 286) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 295) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 297) | fn default<'a>() -> Self::Class<'a> {
    method style (line 301) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 292) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function default (line 307) | pub fn default(theme: &Theme) -> Style {
  function weak (line 319) | pub fn weak(theme: &Theme) -> Style {

FILE: widget/src/scrollable.rs
  type Scrollable (line 66) | pub struct Scrollable<'a, Message, Theme = crate::Theme, Renderer = crat...
  function new (line 88) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function with_direction (line 93) | pub fn with_direction(
  function enclose (line 111) | fn enclose(mut self) -> Self {
  function horizontal (line 126) | pub fn horizontal(self) -> Self {
  function direction (line 131) | pub fn direction(mut self, direction: impl Into<Direction>) -> Self {
  function id (line 137) | pub fn id(mut self, id: impl Into<widget::Id>) -> Self {
  function width (line 143) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 149) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function on_scroll (line 157) | pub fn on_scroll(mut self, f: impl Fn(Viewport) -> Message + 'a) -> Self {
  function anchor_top (line 163) | pub fn anchor_top(self) -> Self {
  function anchor_bottom (line 168) | pub fn anchor_bottom(self) -> Self {
  function anchor_left (line 173) | pub fn anchor_left(self) -> Self {
  function anchor_right (line 178) | pub fn anchor_right(self) -> Self {
  function anchor_x (line 183) | pub fn anchor_x(mut self, alignment: Anchor) -> Self {
  function anchor_y (line 195) | pub fn anchor_y(mut self, alignment: Anchor) -> Self {
  function spacing (line 211) | pub fn spacing(mut self, new_spacing: impl Into<Pixels>) -> Self {
  function auto_scroll (line 226) | pub fn auto_scroll(mut self, auto_scroll: bool) -> Self {
  function style (line 233) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 244) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  type Direction (line 252) | pub enum Direction {
    method horizontal (line 268) | pub fn horizontal(&self) -> Option<&Scrollbar> {
    method vertical (line 277) | pub fn vertical(&self) -> Option<&Scrollbar> {
    method align (line 285) | fn align(&self, delta: Vector) -> Vector {
  method default (line 303) | fn default() -> Self {
  type Scrollbar (line 310) | pub struct Scrollbar {
    method new (line 332) | pub fn new() -> Self {
    method hidden (line 338) | pub fn hidden() -> Self {
    method width (line 343) | pub fn width(mut self, width: impl Into<Pixels>) -> Self {
    method margin (line 349) | pub fn margin(mut self, margin: impl Into<Pixels>) -> Self {
    method scroller_width (line 355) | pub fn scroller_width(mut self, scroller_width: impl Into<Pixels>) -> ...
    method anchor (line 361) | pub fn anchor(mut self, alignment: Anchor) -> Self {
    method spacing (line 371) | pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
    method is_mouse_over (line 1985) | pub fn is_mouse_over(&self, cursor_position: Point) -> bool {
    method scroll_percentage_y (line 1990) | pub fn scroll_percentage_y(&self, grabbed_at: f32, cursor_position: Po...
    method scroll_percentage_x (line 2006) | pub fn scroll_percentage_x(&self, grabbed_at: f32, cursor_position: Po...
  method default (line 319) | fn default() -> Self {
  type Anchor (line 380) | pub enum Anchor {
  function tag (line 394) | fn tag(&self) -> tree::Tag {
  function state (line 398) | fn state(&self) -> tree::State {
  function children (line 402) | fn children(&self) -> Vec<Tree> {
  function diff (line 406) | fn diff(&self, tree: &mut Tree) {
  function size (line 410) | fn size(&self) -> Size<Length> {
  function layout (line 417) | fn layout(
  function operate (line 524) | fn operate(
  function update (line 550) | fn update(
  function draw (line 1028) | fn draw(
  function mouse_interaction (line 1188) | fn mouse_interaction(
  function overlay (line 1233) | fn overlay<'b>(
  type AutoScrollIcon (line 1280) | struct AutoScrollIcon<'a, Class> {
  constant SIZE (line 1288) | const SIZE: f32 = 40.0;
  constant DOT (line 1289) | const DOT: f32 = Self::SIZE / 10.0;
  constant PADDING (line 1290) | const PADDING: f32 = Self::SIZE / 10.0;
  function layout (line 1299) | fn layout(&mut self, _renderer: &Renderer, _bounds: Size) -> layout::Node {
  function draw (line 1304) | fn draw(
  function index (line 1417) | fn index(&self) -> f32 {
  function from (line 1429) | fn from(
  function notify_scroll (line 1436) | fn notify_scroll<Message>(
  function notify_viewport (line 1452) | fn notify_viewport<Message>(
  type State (line 1502) | struct State {
    method snap_to (line 1540) | fn snap_to(&mut self, offset: RelativeOffset<Option<f32>>) {
    method scroll_to (line 1544) | fn scroll_to(&mut self, offset: AbsoluteOffset<Option<f32>>) {
    method scroll_by (line 1548) | fn scroll_by(&mut self, offset: AbsoluteOffset, bounds: Rectangle, con...
    method new (line 1635) | fn new() -> Self {
    method scroll (line 1639) | fn scroll(&mut self, delta: Vector<f32>, bounds: Rectangle, content_bo...
    method scroll_y_to (line 1655) | fn scroll_y_to(&mut self, percentage: f32, bounds: Rectangle, content_...
    method scroll_x_to (line 1660) | fn scroll_x_to(&mut self, percentage: f32, bounds: Rectangle, content_...
    method snap_to (line 1665) | fn snap_to(&mut self, offset: RelativeOffset<Option<f32>>) {
    method scroll_to (line 1675) | fn scroll_to(&mut self, offset: AbsoluteOffset<Option<f32>>) {
    method scroll_by (line 1686) | fn scroll_by(&mut self, offset: AbsoluteOffset, bounds: Rectangle, con...
    method unsnap (line 1692) | fn unsnap(&mut self, bounds: Rectangle, content_bounds: Rectangle) {
    method translation (line 1701) | fn translation(
    method scrollers_grabbed (line 1725) | fn scrollers_grabbed(&self) -> bool {
    method y_scroller_grabbed_at (line 1732) | pub fn y_scroller_grabbed_at(&self) -> Option<f32> {
    method x_scroller_grabbed_at (line 1740) | pub fn x_scroller_grabbed_at(&self) -> Option<f32> {
  type Interaction (line 1513) | enum Interaction {
  method default (line 1526) | fn default() -> Self {
  type Offset (line 1554) | enum Offset {
    method absolute (line 1560) | fn absolute(self, viewport: f32, content: f32) -> f32 {
    method translation (line 1567) | fn translation(self, viewport: f32, content: f32, alignment: Anchor) -...
  type Viewport (line 1579) | pub struct Viewport {
    method absolute_offset (line 1588) | pub fn absolute_offset(&self) -> AbsoluteOffset {
    method absolute_offset_reversed (line 1604) | pub fn absolute_offset_reversed(&self) -> AbsoluteOffset {
    method relative_offset (line 1614) | pub fn relative_offset(&self) -> RelativeOffset {
    method bounds (line 1624) | pub fn bounds(&self) -> Rectangle {
    method content_bounds (line 1629) | pub fn content_bounds(&self) -> Rectangle {
  type Scrollbars (line 1751) | struct Scrollbars {
    method new (line 1758) | fn new(
    method is_mouse_over (line 1909) | fn is_mouse_over(&self, cursor: mouse::Cursor) -> (bool, bool) {
    method is_y_disabled (line 1926) | fn is_y_disabled(&self) -> bool {
    method is_x_disabled (line 1930) | fn is_x_disabled(&self) -> bool {
    method grab_y_scroller (line 1934) | fn grab_y_scroller(&self, cursor_position: Point) -> Option<f32> {
    method grab_x_scroller (line 1949) | fn grab_x_scroller(&self, cursor_position: Point) -> Option<f32> {
    method active (line 1964) | fn active(&self) -> bool {
  type Scrollbar (line 1975) | pub struct Scrollbar {
    method new (line 332) | pub fn new() -> Self {
    method hidden (line 338) | pub fn hidden() -> Self {
    method width (line 343) | pub fn width(mut self, width: impl Into<Pixels>) -> Self {
    method margin (line 349) | pub fn margin(mut self, margin: impl Into<Pixels>) -> Self {
    method scroller_width (line 355) | pub fn scroller_width(mut self, scroller_width: impl Into<Pixels>) -> ...
    method anchor (line 361) | pub fn anchor(mut self, alignment: Anchor) -> Self {
    method spacing (line 371) | pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
    method is_mouse_over (line 1985) | pub fn is_mouse_over(&self, cursor_position: Point) -> bool {
    method scroll_percentage_y (line 1990) | pub fn scroll_percentage_y(&self, grabbed_at: f32, cursor_position: Po...
    method scroll_percentage_x (line 2006) | pub fn scroll_percentage_x(&self, grabbed_at: f32, cursor_position: Po...
  type Scroller (line 2024) | pub struct Scroller {
  type Status (line 2032) | pub enum Status {
  type Style (line 2066) | pub struct Style {
  type Rail (line 2081) | pub struct Rail {
  type Scroller (line 2092) | pub struct Scroller {
  type AutoScroll (line 2101) | pub struct AutoScroll {
  type Catalog (line 2113) | pub trait Catalog {
    method default (line 2118) | fn default<'a>() -> Self::Class<'a>;
    method style (line 2121) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 2128) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 2130) | fn default<'a>() -> Self::Class<'a> {
    method style (line 2134) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 2125) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 2140) | pub fn default(theme: &Theme, status: Status) -> Style {

FILE: widget/src/sensor.rs
  type Sensor (line 17) | pub struct Sensor<'a, Key, Message, Theme = crate::Theme, Renderer = cra...
  function new (line 32) | pub fn new(content: impl Into<Element<'a, Message, Theme, Renderer>>) ->...
  function on_show (line 53) | pub fn on_show(mut self, on_show: impl Fn(Size) -> Message + 'a) -> Self {
  function on_resize (line 61) | pub fn on_resize(mut self, on_resize: impl Fn(Size) -> Message + 'a) -> ...
  function on_hide (line 67) | pub fn on_hide(mut self, on_hide: Message) -> Self {
  function key (line 75) | pub fn key<K>(self, key: K) -> Sensor<'a, impl self::Key, Message, Theme...
  function key_ref (line 93) | pub fn key_ref<K>(self, key: &'a K) -> Sensor<'a, &'a K, Message, Theme,...
  function anticipate (line 114) | pub fn anticipate(mut self, distance: impl Into<Pixels>) -> Self {
  function delay (line 127) | pub fn delay(mut self, delay: impl Into<Duration>) -> Self {
  type State (line 134) | struct State<Key> {
  function tag (line 147) | fn tag(&self) -> tree::Tag {
  function state (line 151) | fn state(&self) -> tree::State {
  function children (line 160) | fn children(&self) -> Vec<Tree> {
  function diff (line 164) | fn diff(&self, tree: &mut Tree) {
  function update (line 168) | fn update(
  function size (line 256) | fn size(&self) -> Size<Length> {
  function size_hint (line 260) | fn size_hint(&self) -> Size<Length> {
  function layout (line 264) | fn layout(
  function draw (line 275) | fn draw(
  function operate (line 296) | fn operate(
  function mouse_interaction (line 308) | fn mouse_interaction(
  function overlay (line 325) | fn overlay<'b>(
  function from (line 351) | fn from(pop: Sensor<'a, Key, Message, Theme, Renderer>) -> Self {
  type Key (line 359) | pub trait Key {
    method to_owned (line 364) | fn to_owned(&self) -> Self::Owned;
    method eq (line 367) | fn eq(&self, other: &Self::Owned) -> bool;
    type Owned (line 375) | type Owned = T::Owned;
    method to_owned (line 377) | fn to_owned(&self) -> <Self as Key>::Owned {
    method eq (line 381) | fn eq(&self, other: &Self::Owned) -> bool {
    type Owned (line 392) | type Owned = T;
    method to_owned (line 394) | fn to_owned(&self) -> Self::Owned {
    method eq (line 398) | fn eq(&self, other: &Self::Owned) -> bool {
    type Owned (line 413) | type Owned = ();
    method to_owned (line 415) | fn to_owned(&self) -> Self::Owned {}
    method eq (line 417) | fn eq(&self, _other: &Self::Owned) -> bool {
  type OwnedKey (line 386) | struct OwnedKey<T>(T);
  function eq (line 407) | fn eq(&self, other: &T) -> bool {

FILE: widget/src/shader.rs
  type Shader (line 25) | pub struct Shader<Message, P: Program<Message>> {
  function new (line 34) | pub fn new(program: P) -> Self {
  function width (line 44) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 50) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function tag (line 61) | fn tag(&self) -> tree::Tag {
  function state (line 66) | fn state(&self) -> tree::State {
  function size (line 70) | fn size(&self) -> Size<Length> {
  function layout (line 77) | fn layout(
  function update (line 86) | fn update(
  function mouse_interaction (line 115) | fn mouse_interaction(
  function draw (line 129) | fn draw(
  function from (line 153) | fn from(custom: Shader<Message, P>) -> Element<'a, Message, Theme, Rende...
  type State (line 162) | type State = T::State;
  type Primitive (line 163) | type Primitive = T::Primitive;
  function update (line 165) | fn update(
  function draw (line 175) | fn draw(
  function mouse_interaction (line 184) | fn mouse_interaction(

FILE: widget/src/shader/program.rs
  type Program (line 12) | pub trait Program<Message> {
    method update (line 26) | fn update(
    method draw (line 39) | fn draw(
    method mouse_interaction (line 52) | fn mouse_interaction(

FILE: widget/src/slider.rs
  type Slider (line 83) | pub struct Slider<'a, T, Message, Theme = crate::Theme>
  constant DEFAULT_HEIGHT (line 107) | pub const DEFAULT_HEIGHT: f32 = 16.0;
  function new (line 117) | pub fn new<F>(range: RangeInclusive<T>, value: T, on_change: F) -> Self
  function default (line 151) | pub fn default(mut self, default: impl Into<T>) -> Self {
  function on_release (line 162) | pub fn on_release(mut self, on_release: Message) -> Self {
  function width (line 168) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 174) | pub fn height(mut self, height: impl Into<Pixels>) -> Self {
  function step (line 180) | pub fn step(mut self, step: impl Into<T>) -> Self {
  function shift_step (line 188) | pub fn shift_step(mut self, shift_step: impl Into<T>) -> Self {
  function style (line 195) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 206) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 219) | fn tag(&self) -> tree::Tag {
  function state (line 223) | fn state(&self) -> tree::State {
  function size (line 227) | fn size(&self) -> Size<Length> {
  function layout (line 234) | fn layout(
  function update (line 243) | fn update(
  function draw (line 419) | fn draw(
  function mouse_interaction (line 503) | fn mouse_interaction(
  function from (line 541) | fn from(slider: Slider<'a, T, Message, Theme>) -> Element<'a, Message, T...
  type State (line 547) | struct State {
  type Status (line 554) | pub enum Status {
  type Style (line 565) | pub struct Style {
    method with_circular_handle (line 575) | pub fn with_circular_handle(mut self, radius: impl Into<Pixels>) -> Se...
  type Rail (line 585) | pub struct Rail {
  type Handle (line 596) | pub struct Handle {
  type HandleShape (line 609) | pub enum HandleShape {
  type Catalog (line 625) | pub trait Catalog: Sized {
    method default (line 630) | fn default<'a>() -> Self::Class<'a>;
    method style (line 633) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 640) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 642) | fn default<'a>() -> Self::Class<'a> {
    method style (line 646) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 637) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 652) | pub fn default(theme: &Theme, status: Status) -> Style {

FILE: widget/src/space.rs
  function horizontal (line 13) | pub fn horizontal() -> Space {
  function vertical (line 21) | pub fn vertical() -> Space {
  type Space (line 29) | pub struct Space {
    method new (line 36) | pub fn new() -> Self {
    method width (line 44) | pub fn width(mut self, width: impl Into<Length>) -> Self {
    method height (line 50) | pub fn height(mut self, height: impl Into<Length>) -> Self {
    method size (line 66) | fn size(&self) -> Size<Length> {
    method layout (line 73) | fn layout(
    method draw (line 82) | fn draw(
  method default (line 57) | fn default() -> Self {
  function from (line 100) | fn from(space: Space) -> Element<'a, Message, Theme, Renderer> {

FILE: widget/src/stack.rs
  type Stack (line 20) | pub struct Stack<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  function new (line 33) | pub fn new() -> Self {
  function with_capacity (line 38) | pub fn with_capacity(capacity: usize) -> Self {
  function with_children (line 43) | pub fn with_children(
  function from_vec (line 58) | pub fn from_vec(children: Vec<Element<'a, Message, Theme, Renderer>>) ->...
  function width (line 69) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 75) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function push (line 81) | pub fn push(mut self, child: impl Into<Element<'a, Message, Theme, Rende...
  function push_under (line 98) | pub fn push_under(mut self, child: impl Into<Element<'a, Message, Theme,...
  function extend (line 105) | pub fn extend(
  function clip (line 117) | pub fn clip(mut self, clip: bool) -> Self {
  method default (line 127) | fn default() -> Self {
  function children (line 137) | fn children(&self) -> Vec<Tree> {
  function diff (line 141) | fn diff(&self, tree: &mut Tree) {
  function size (line 145) | fn size(&self) -> Size<Length> {
  function layout (line 152) | fn layout(
  function operate (line 192) | fn operate(
  function update (line 213) | fn update(
  function mouse_interaction (line 258) | fn mouse_interaction(
  function draw (line 280) | fn draw(
  function overlay (line 350) | fn overlay<'b>(
  function from (line 376) | fn from(stack: Stack<'a, Message, Theme, Renderer>) -> Self {

FILE: widget/src/svg.rs
  type Svg (line 55) | pub struct Svg<'a, Theme = crate::Theme>
  function new (line 74) | pub fn new(handle: impl Into<Handle>) -> Self {
  function from_path (line 90) | pub fn from_path(path: impl Into<PathBuf>) -> Self {
  function width (line 96) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 103) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function content_fit (line 112) | pub fn content_fit(self, content_fit: ContentFit) -> Self {
  function style (line 121) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 132) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function rotation (line 138) | pub fn rotation(mut self, rotation: impl Into<Rotation>) -> Self {
  function opacity (line 147) | pub fn opacity(mut self, opacity: impl Into<f32>) -> Self {
  function size (line 158) | fn size(&self) -> Size<Length> {
  function layout (line 165) | fn layout(
  function update (line 199) | fn update(
  function draw (line 222) | fn draw(
  function from (line 278) | fn from(icon: Svg<'a, Theme>) -> Element<'a, Message, Theme, Renderer> {
  type Status (line 285) | pub enum Status {
  type Style (line 294) | pub struct Style {
  type Catalog (line 304) | pub trait Catalog {
    method default (line 309) | fn default<'a>() -> Self::Class<'a>;
    method style (line 312) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 316) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 318) | fn default<'a>() -> Self::Class<'a> {
    method style (line 322) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 330) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function from (line 333) | fn from(style: Style) -> Self {

FILE: widget/src/table.rs
  function table (line 17) | pub fn table<'a, 'b, T, Message, Theme, Renderer>(
  function column (line 33) | pub fn column<'a, 'b, T, E, Message, Theme, Renderer>(
  type Table (line 51) | pub struct Table<'a, Message, Theme = crate::Theme, Renderer = crate::Re...
  type Column_ (line 66) | struct Column_ {
  function new (line 81) | pub fn new<'b, T>(
  function width (line 144) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function padding (line 150) | pub fn padding(self, padding: impl Into<Pixels>) -> Self {
  function padding_x (line 157) | pub fn padding_x(mut self, padding: impl Into<Pixels>) -> Self {
  function padding_y (line 163) | pub fn padding_y(mut self, padding: impl Into<Pixels>) -> Self {
  function separator (line 169) | pub fn separator(self, separator: impl Into<Pixels>) -> Self {
  function separator_x (line 176) | pub fn separator_x(mut self, separator: impl Into<Pixels>) -> Self {
  function separator_y (line 182) | pub fn separator_y(mut self, separator: impl Into<Pixels>) -> Self {
  type Metrics (line 188) | struct Metrics {
  function size (line 199) | fn size(&self) -> Size<Length> {
  function tag (line 206) | fn tag(&self) -> widget::tree::Tag {
  function state (line 210) | fn state(&self) -> widget::tree::State {
  function children (line 217) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 224) | fn diff(&self, tree: &mut widget::Tree) {
  function layout (line 228) | fn layout(
  function update (line 448) | fn update(
  function draw (line 469) | fn draw(
  function mouse_interaction (line 538) | fn mouse_interaction(
  function operate (line 558) | fn operate(
  function overlay (line 576) | fn overlay<'b>(
  function from (line 602) | fn from(table: Table<'a, Message, Theme, Renderer>) -> Self {
  type Column (line 608) | pub struct Column<'a, 'b, T, Message, Theme = crate::Theme, Renderer = c...
  function width (line 618) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function align_x (line 624) | pub fn align_x(mut self, alignment: impl Into<alignment::Horizontal>) ->...
  function align_y (line 630) | pub fn align_y(mut self, alignment: impl Into<alignment::Vertical>) -> S...
  type Style (line 638) | pub struct Style {
  type Catalog (line 646) | pub trait Catalog {
    method default (line 651) | fn default<'a>() -> Self::Class<'a>;
    method style (line 654) | fn style(&self, class: &Self::Class<'_>) -> Style;
    type Class (line 667) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 669) | fn default<'a>() -> Self::Class<'a> {
    method style (line 673) | fn style(&self, class: &Self::Class<'_>) -> Style {
  type StyleFn (line 658) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme) -> Style + 'a>;
  function from (line 661) | fn from(style: Style) -> Self {
  function default (line 679) | pub fn default(theme: &crate::Theme) -> Style {

FILE: widget/src/text.rs
  type Text (line 29) | pub type Text<'a, Theme = crate::Theme, Renderer = crate::Renderer> =

FILE: widget/src/text/rich.rs
  type Rich (line 16) | pub struct Rich<'a, Link, Message, Theme = crate::Theme, Renderer = crat...
  function new (line 45) | pub fn new() -> Self {
  function with_spans (line 64) | pub fn with_spans(spans: impl AsRef<[Span<'a, Link, Renderer::Font>]> + ...
  function size (line 72) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 78) | pub fn line_height(mut self, line_height: impl Into<LineHeight>) -> Self {
  function font (line 84) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function width (line 90) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function height (line 96) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function center (line 102) | pub fn center(self) -> Self {
  function align_x (line 108) | pub fn align_x(mut self, alignment: impl Into<Alignment>) -> Self {
  function align_y (line 114) | pub fn align_y(mut self, alignment: impl Into<alignment::Vertical>) -> S...
  function wrapping (line 120) | pub fn wrapping(mut self, wrapping: Wrapping) -> Self {
  function ellipsis (line 126) | pub fn ellipsis(mut self, ellipsis: Ellipsis) -> Self {
  function on_link_click (line 137) | pub fn on_link_click(mut self, on_link_click: impl Fn(Link) -> Message +...
  function style (line 144) | pub fn style(mut self, style: impl Fn(&Theme) -> Style + 'a) -> Self
  function color (line 153) | pub fn color(self, color: impl Into<Color>) -> Self
  function color_maybe (line 161) | pub fn color_maybe(self, color: Option<impl Into<Color>>) -> Self
  function class (line 173) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  method default (line 186) | fn default() -> Self {
  type State (line 191) | struct State<Link, P: Paragraph> {
  function tag (line 204) | fn tag(&self) -> tree::Tag {
  function state (line 208) | fn state(&self) -> tree::State {
  function size (line 216) | fn size(&self) -> Size<Length> {
  function layout (line 223) | fn layout(
  function draw (line 247) | fn draw(
  function update (line 350) | fn update(
  function mouse_interaction (line 423) | fn mouse_interaction(
  function layout (line 439) | fn layout<Link, Renderer>(
  function from_iter (line 517) | fn from_iter<T: IntoIterator<Item = Span<'a, Link, Renderer::Font>>>(spa...
  function from (line 530) | fn from(

FILE: widget/src/text_editor.rs
  type TextEditor (line 97) | pub struct TextEditor<'a, Highlighter, Message, Theme = crate::Theme, Re...
  function new (line 129) | pub fn new(content: &'a Content<Renderer>) -> Self {
  function id (line 161) | pub fn id(mut self, id: impl Into<widget::Id>) -> Self {
  function placeholder (line 167) | pub fn placeholder(mut self, placeholder: impl text::IntoFragment<'a>) -...
  function width (line 173) | pub fn width(mut self, width: impl Into<Pixels>) -> Self {
  function height (line 179) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function min_height (line 185) | pub fn min_height(mut self, min_height: impl Into<Pixels>) -> Self {
  function max_height (line 191) | pub fn max_height(mut self, max_height: impl Into<Pixels>) -> Self {
  function on_action (line 200) | pub fn on_action(mut self, on_edit: impl Fn(Action) -> Message + 'a) -> ...
  function font (line 208) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function size (line 214) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 220) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function padding (line 226) | pub fn padding(mut self, padding: impl Into<Padding>) -> Self {
  function wrapping (line 232) | pub fn wrapping(mut self, wrapping: Wrapping) -> Self {
  function highlight (line 239) | pub fn highlight(
  function highlight_with (line 258) | pub fn highlight_with<H: text::Highlighter>(
  function key_binding (line 288) | pub fn key_binding(
  function style (line 298) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 309) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function input_method (line 314) | fn input_method<'b>(
  type Content (line 354) | pub struct Content<R = crate::Renderer>(RefCell<Internal<R>>)
  type Internal (line 358) | struct Internal<R>
  function new (line 370) | pub fn new() -> Self {
  function with_text (line 375) | pub fn with_text(text: &str) -> Self {
  function perform (line 382) | pub fn perform(&mut self, action: Action) {
  function move_to (line 389) | pub fn move_to(&mut self, cursor: Cursor) {
  function cursor (line 396) | pub fn cursor(&self) -> Cursor {
  function line_count (line 401) | pub fn line_count(&self) -> usize {
  function line (line 406) | pub fn line(&self, index: usize) -> Option<Line<'_>> {
  function lines (line 417) | pub fn lines(&self) -> impl Iterator<Item = Line<'_>> {
  function text (line 425) | pub fn text(&self) -> String {
  function selection (line 445) | pub fn selection(&self) -> Option<String> {
  function line_ending (line 450) | pub fn line_ending(&self) -> Option<LineEnding> {
  function is_empty (line 455) | pub fn is_empty(&self) -> bool {
  method clone (line 464) | fn clone(&self) -> Self {
  method default (line 473) | fn default() -> Self {
  function fmt (line 483) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type State (line 494) | pub struct State<Highlighter: text::Highlighter> {
  type Focus (line 507) | struct Focus {
    constant CURSOR_BLINK_INTERVAL_MILLIS (line 514) | const CURSOR_BLINK_INTERVAL_MILLIS: u128 = 500;
    method now (line 516) | fn now() -> Self {
    method is_cursor_visible (line 526) | fn is_cursor_visible(&self) -> bool {
  function is_focused (line 535) | pub fn is_focused(&self) -> bool {
  function is_focused (line 541) | fn is_focused(&self) -> bool {
  function focus (line 545) | fn focus(&mut self) {
  function unfocus (line 549) | fn unfocus(&mut self) {
  function tag (line 561) | fn tag(&self) -> widget::tree::Tag {
  function state (line 565) | fn state(&self) -> widget::tree::State {
  function size (line 579) | fn size(&self) -> Size<Length> {
  function layout (line 586) | fn layout(
  function update (line 643) | fn update(
  function draw (line 871) | fn draw(
  function mouse_interaction (line 1002) | fn mouse_interaction(
  function operate (line 1023) | fn operate(
  function from (line 1045) | fn from(text_editor: TextEditor<'a, Highlighter, Message, Theme, Rendere...
  type Binding (line 1052) | pub enum Binding<Message> {
  type KeyPress (line 1087) | pub struct KeyPress {
  function from_key_press (line 1110) | pub fn from_key_press(event: KeyPress) -> Option<Self> {
  type Update (line 1185) | enum Update<Message> {
  type Ime (line 1194) | enum Ime {
  function from_event (line 1204) | fn from_event<H: Highlighter>(
  function motion (line 1310) | fn motion(key: key::Named) -> Option<Motion> {
  type Status (line 1326) | pub enum Status {
  type Style (line 1342) | pub struct Style {
  type Catalog (line 1356) | pub trait Catalog: theme::Base {
    method default (line 1361) | fn default<'a>() -> Self::Class<'a>;
    method style (line 1364) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 1371) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 1373) | fn default<'a>() -> Self::Class<'a> {
    method style (line 1377) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 1368) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 1383) | pub fn default(theme: &Theme, status: Status) -> Style {
  function convert_macos_shortcut (line 1424) | pub(crate) fn convert_macos_shortcut(

FILE: widget/src/text_input.rs
  type TextInput (line 96) | pub struct TextInput<'a, Message, Theme = crate::Theme, Renderer = crate...
  constant DEFAULT_PADDING (line 120) | pub const DEFAULT_PADDING: Padding = Padding::new(5.0);
  function new (line 130) | pub fn new(placeholder: &str, value: &str) -> Self {
  function id (line 152) | pub fn id(mut self, id: impl Into<widget::Id>) -> Self {
  function secure (line 158) | pub fn secure(mut self, is_secure: bool) -> Self {
  function on_input (line 167) | pub fn on_input(mut self, on_input: impl Fn(String) -> Message + 'a) -> ...
  function on_input_maybe (line 176) | pub fn on_input_maybe(mut self, on_input: Option<impl Fn(String) -> Mess...
  function on_submit (line 183) | pub fn on_submit(mut self, message: Message) -> Self {
  function on_submit_maybe (line 190) | pub fn on_submit_maybe(mut self, on_submit: Option<Message>) -> Self {
  function on_paste (line 197) | pub fn on_paste(mut self, on_paste: impl Fn(String) -> Message + 'a) -> ...
  function on_paste_maybe (line 204) | pub fn on_paste_maybe(mut self, on_paste: Option<impl Fn(String) -> Mess...
  function font (line 212) | pub fn font(mut self, font: Renderer::Font) -> Self {
  function icon (line 218) | pub fn icon(mut self, icon: Icon<Renderer::Font>) -> Self {
  function width (line 224) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function padding (line 230) | pub fn padding<P: Into<Padding>>(mut self, padding: P) -> Self {
  function size (line 236) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function line_height (line 242) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function align_x (line 248) | pub fn align_x(mut self, alignment: impl Into<alignment::Horizontal>) ->...
  function style (line 255) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 265) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function layout (line 273) | pub fn layout(
  function input_method (line 363) | fn input_method<'b>(
  function draw (line 414) | pub fn draw(
  function tag (line 598) | fn tag(&self) -> tree::Tag {
  function state (line 602) | fn state(&self) -> tree::State {
  function diff (line 606) | fn diff(&self, tree: &mut Tree) {
  function size (line 615) | fn size(&self) -> Size<Length> {
  function layout (line 622) | fn layout(
  function operate (line 631) | fn operate(
  function update (line 644) | fn update(
  function draw (line 1290) | fn draw(
  function mouse_interaction (line 1303) | fn mouse_interaction(
  function from (line 1330) | fn from(
  type Icon (line 1339) | pub struct Icon<Font> {
  type Side (line 1354) | pub enum Side {
  type State (line 1363) | pub struct State<P: text::Paragraph> {
  function state (line 1377) | fn state<Renderer: text::Renderer>(tree: &mut Tree) -> &mut State<Render...
  type Focus (line 1382) | struct Focus {
  type Drag (line 1389) | enum Drag {
  type Paste (line 1395) | enum Paste {
  function new (line 1402) | pub fn new() -> Self {
  function is_focused (line 1407) | pub fn is_focused(&self) -> bool {
  function cursor (line 1412) | pub fn cursor(&self) -> Cursor {
  function focus (line 1417) | pub fn focus(&mut self) {
  function unfocus (line 1430) | pub fn unfocus(&mut self) {
  function move_cursor_to_front (line 1435) | pub fn move_cursor_to_front(&mut self) {
  function move_cursor_to_end (line 1440) | pub fn move_cursor_to_end(&mut self) {
  function move_cursor_to (line 1445) | pub fn move_cursor_to(&mut self, position: usize) {
  function select_all (line 1450) | pub fn select_all(&mut self) {
  function select_range (line 1455) | pub fn select_range(&mut self, start: usize, end: usize) {
  function is_focused (line 1461) | fn is_focused(&self) -> bool {
  function focus (line 1465) | fn focus(&mut self) {
  function unfocus (line 1469) | fn unfocus(&mut self) {
  function text (line 1475) | fn text(&self) -> &str {
  function move_cursor_to_front (line 1483) | fn move_cursor_to_front(&mut self) {
  function move_cursor_to_end (line 1487) | fn move_cursor_to_end(&mut self) {
  function move_cursor_to (line 1491) | fn move_cursor_to(&mut self, position: usize) {
  function select_all (line 1495) | fn select_all(&mut self) {
  function select_range (line 1499) | fn select_range(&mut self, start: usize, end: usize) {
  function offset (line 1504) | fn offset<P: text::Paragraph>(text_bounds: Rectangle, value: &Value, sta...
  function measure_cursor_and_scroll_offset (line 1522) | fn measure_cursor_and_scroll_offset(
  function find_cursor_position (line 1538) | fn find_cursor_position<P: text::Paragraph>(
  function replace_paragraph (line 1562) | fn replace_paragraph<Renderer>(
  constant CURSOR_BLINK_INTERVAL_MILLIS (line 1594) | const CURSOR_BLINK_INTERVAL_MILLIS: u128 = 500;
  type Status (line 1598) | pub enum Status {
  type Style (line 1614) | pub struct Style {
  type Catalog (line 1630) | pub trait Catalog: Sized {
    method default (line 1635) | fn default<'a>() -> Self::Class<'a>;
    method style (line 1638) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 1647) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 1649) | fn default<'a>() -> Self::Class<'a> {
    method style (line 1653) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 1644) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 1659) | pub fn default(theme: &Theme, status: Status) -> Style {
  function alignment_offset (line 1700) | fn alignment_offset(

FILE: widget/src/text_input/cursor.rs
  type Cursor (line 6) | pub struct Cursor {
    method state (line 35) | pub fn state(&self, value: &Value) -> State {
    method selection (line 54) | pub fn selection(&self, value: &Value) -> Option<(usize, usize)> {
    method move_to (line 61) | pub(crate) fn move_to(&mut self, position: usize) {
    method move_right (line 65) | pub(crate) fn move_right(&mut self, value: &Value) {
    method move_right_by_words (line 69) | pub(crate) fn move_right_by_words(&mut self, value: &Value) {
    method move_right_by_amount (line 73) | pub(crate) fn move_right_by_amount(&mut self, value: &Value, amount: u...
    method move_left (line 82) | pub(crate) fn move_left(&mut self, value: &Value) {
    method move_left_by_words (line 90) | pub(crate) fn move_left_by_words(&mut self, value: &Value) {
    method select_range (line 94) | pub(crate) fn select_range(&mut self, start: usize, end: usize) {
    method select_left (line 102) | pub(crate) fn select_left(&mut self, value: &Value) {
    method select_right (line 114) | pub(crate) fn select_right(&mut self, value: &Value) {
    method select_left_by_words (line 126) | pub(crate) fn select_left_by_words(&mut self, value: &Value) {
    method select_right_by_words (line 137) | pub(crate) fn select_right_by_words(&mut self, value: &Value) {
    method select_all (line 148) | pub(crate) fn select_all(&mut self, value: &Value) {
    method start (line 152) | pub(crate) fn start(&self, value: &Value) -> usize {
    method end (line 161) | pub(crate) fn end(&self, value: &Value) -> usize {
    method left (line 170) | fn left(&self, value: &Value) -> usize {
    method right (line 177) | fn right(&self, value: &Value) -> usize {
  type State (line 12) | pub enum State {
  method default (line 26) | fn default() -> Self {

FILE: widget/src/text_input/editor.rs
  type Editor (line 3) | pub struct Editor<'a> {
  function new (line 9) | pub fn new(value: &'a mut Value, cursor: &'a mut Cursor) -> Editor<'a> {
  function contents (line 13) | pub fn contents(&self) -> String {
  function insert (line 17) | pub fn insert(&mut self, character: char) {
  function paste (line 27) | pub fn paste(&mut self, content: Value) {
  function backspace (line 39) | pub fn backspace(&mut self) {
  function delete (line 56) | pub fn delete(&mut self) {

FILE: widget/src/text_input/value.rs
  type Value (line 8) | pub struct Value {
    method new (line 14) | pub fn new(string: &str) -> Self {
    method is_empty (line 25) | pub fn is_empty(&self) -> bool {
    method len (line 30) | pub fn len(&self) -> usize {
    method previous_start_of_word (line 36) | pub fn previous_start_of_word(&self, index: usize) -> usize {
    method next_end_of_word (line 55) | pub fn next_end_of_word(&self, index: usize) -> usize {
    method select (line 70) | pub fn select(&self, start: usize, end: usize) -> Self {
    method until (line 78) | pub fn until(&self, index: usize) -> Self {
    method insert (line 85) | pub fn insert(&mut self, index: usize, c: char) {
    method insert_many (line 94) | pub fn insert_many(&mut self, index: usize, mut value: Value) {
    method remove (line 101) | pub fn remove(&mut self, index: usize) {
    method remove_many (line 106) | pub fn remove_many(&mut self, start: usize, end: usize) {
    method secure (line 112) | pub fn secure(&self) -> Self {
    method fmt (line 120) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: widget/src/themer.rs
  type Themer (line 17) | pub struct Themer<'a, Message, Theme, Renderer = crate::Renderer>
  function new (line 33) | pub fn new(
  function text_color (line 46) | pub fn text_color(mut self, f: fn(&Theme) -> Color) -> Self {
  function background (line 52) | pub fn background(mut self, f: fn(&Theme) -> Background) -> Self {
  function tag (line 65) | fn tag(&self) -> tree::Tag {
  function state (line 69) | fn state(&self) -> tree::State {
  function children (line 73) | fn children(&self) -> Vec<Tree> {
  function diff (line 77) | fn diff(&self, tree: &mut Tree) {
  function size (line 81) | fn size(&self) -> Size<Length> {
  function layout (line 85) | fn layout(
  function operate (line 94) | fn operate(
  function update (line 106) | fn update(
  function mouse_interaction (line 121) | fn mouse_interaction(
  function draw (line 134) | fn draw(
  function overlay (line 171) | fn overlay<'b>(
  function from (line 281) | fn from(

FILE: widget/src/toggler.rs
  type Toggler (line 80) | pub struct Toggler<'a, Message, Theme = crate::Theme, Renderer = crate::...
  constant DEFAULT_SIZE (line 107) | pub const DEFAULT_SIZE: f32 = 16.0;
  function new (line 117) | pub fn new(is_toggled: bool) -> Self {
  function label (line 137) | pub fn label(mut self, label: impl text::IntoFragment<'a>) -> Self {
  function on_toggle (line 146) | pub fn on_toggle(mut self, on_toggle: impl Fn(bool) -> Message + 'a) -> ...
  function on_toggle_maybe (line 155) | pub fn on_toggle_maybe(mut self, on_toggle: Option<impl Fn(bool) -> Mess...
  function size (line 161) | pub fn size(mut self, size: impl Into<Pixels>) -> Self {
  function width (line 167) | pub fn width(mut self, width: impl Into<Length>) -> Self {
  function text_size (line 173) | pub fn text_size(mut self, text_size: impl Into<Pixels>) -> Self {
  function line_height (line 179) | pub fn line_height(mut self, line_height: impl Into<text::LineHeight>) -...
  function alignment (line 185) | pub fn alignment(mut self, alignment: impl Into<text::Alignment>) -> Self {
  function shaping (line 191) | pub fn shaping(mut self, shaping: text::Shaping) -> Self {
  function wrapping (line 197) | pub fn wrapping(mut self, wrapping: text::Wrapping) -> Self {
  function spacing (line 203) | pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
  function font (line 211) | pub fn font(mut self, font: impl Into<Renderer::Font>) -> Self {
  function style (line 218) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 229) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 241) | fn tag(&self) -> tree::Tag {
  function state (line 245) | fn state(&self) -> tree::State {
  function size (line 249) | fn size(&self) -> Size<Length> {
  function layout (line 256) | fn layout(
  function update (line 313) | fn update(
  function mouse_interaction (line 364) | fn mouse_interaction(
  function draw (line 383) | fn draw(
  function from (line 484) | fn from(
  type Status (line 493) | pub enum Status {
  type Style (line 513) | pub struct Style {
  type Catalog (line 537) | pub trait Catalog: Sized {
    method default (line 542) | fn default<'a>() -> Self::Class<'a>;
    method style (line 545) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style;
    type Class (line 554) | type Class<'a> = StyleFn<'a, Self>;
    method default (line 556) | fn default<'a>() -> Self::Class<'a> {
    method style (line 560) | fn style(&self, class: &Self::Class<'_>, status: Status) -> Style {
  type StyleFn (line 551) | pub type StyleFn<'a, Theme> = Box<dyn Fn(&Theme, Status) -> Style + 'a>;
  function default (line 566) | pub fn default(theme: &Theme, status: Status) -> Style {

FILE: widget/src/tooltip.rs
  type Tooltip (line 61) | pub struct Tooltip<'a, Message, Theme = crate::Theme, Renderer = crate::...
  constant DEFAULT_PADDING (line 82) | const DEFAULT_PADDING: f32 = 5.0;
  function new (line 87) | pub fn new(
  function gap (line 105) | pub fn gap(mut self, gap: impl Into<Pixels>) -> Self {
  function padding (line 111) | pub fn padding(mut self, padding: impl Into<Pixels>) -> Self {
  function delay (line 119) | pub fn delay(mut self, delay: Duration) -> Self {
  function snap_within_viewport (line 125) | pub fn snap_within_viewport(mut self, snap: bool) -> Self {
  function style (line 132) | pub fn style(mut self, style: impl Fn(&Theme) -> container::Style + 'a) ...
  function class (line 143) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function children (line 155) | fn children(&self) -> Vec<widget::Tree> {
  function diff (line 162) | fn diff(&self, tree: &mut widget::Tree) {
  function state (line 166) | fn state(&self) -> widget::tree::State {
  function tag (line 170) | fn tag(&self) -> widget::tree::Tag {
  function size (line 174) | fn size(&self) -> Size<Length> {
  function size_hint (line 178) | fn size_hint(&self) -> Size<Length> {
  function layout (line 182) | fn layout(
  function update (line 193) | fn update(
  function mouse_interaction (line 263) | fn mouse_interaction(
  function draw (line 280) | fn draw(
  function overlay (line 301) | fn overlay<'b>(
  function operate (line 348) | fn operate(
  function from (line 374) | fn from(
  type Position (line 383) | pub enum Position {
  type State (line 398) | enum State {
  type Overlay (line 409) | struct Overlay<'a, 'b, Message, Theme, Renderer>
  function layout (line 432) | fn layout(&mut self, renderer: &Renderer, bounds: Size) -> layout::Node {
  function draw (line 510) | fn draw(

FILE: widget/src/vertical_slider.rs
  type VerticalSlider (line 82) | pub struct VerticalSlider<'a, T, Message, Theme = crate::Theme>
  constant DEFAULT_WIDTH (line 106) | pub const DEFAULT_WIDTH: f32 = 16.0;
  function new (line 116) | pub fn new<F>(range: RangeInclusive<T>, value: T, on_change: F) -> Self
  function default (line 150) | pub fn default(mut self, default: impl Into<T>) -> Self {
  function on_release (line 161) | pub fn on_release(mut self, on_release: Message) -> Self {
  function width (line 167) | pub fn width(mut self, width: impl Into<Pixels>) -> Self {
  function height (line 173) | pub fn height(mut self, height: impl Into<Length>) -> Self {
  function step (line 179) | pub fn step(mut self, step: T) -> Self {
  function shift_step (line 187) | pub fn shift_step(mut self, shift_step: impl Into<T>) -> Self {
  function style (line 194) | pub fn style(mut self, style: impl Fn(&Theme, Status) -> Style + 'a) -> ...
  function class (line 205) | pub fn class(mut self, class: impl Into<Theme::Class<'a>>) -> Self {
  function tag (line 219) | fn tag(&self) -> tree::Tag {
  function state (line 223) | fn state(&self) -> tree::State {
  function size (line 227) | fn size(&self) -> Size<Length> {
  function layout (line 234) | fn layout(
  function update (line 243) | fn update(
  function draw (line 416) | fn draw(
  function mouse_interaction (line 500) | fn mouse_interaction(
  function from (line 538) | fn from(
  type State (line 546) | struct State {

FILE: winit/src/clipboard.rs
  method default (line 7) | fn default() -> Self {
  type Clipboard (line 21) | pub struct Clipboard {
    method new (line 34) | pub fn new() -> Self {
    method read (line 48) | pub fn read(
    method write (line 95) | pub fn write(
    method new (line 165) | pub fn new() -> Self {
    method read (line 170) | pub fn read(&self, _kind: Kind, callback: impl FnOnce(Result<Content, ...
    method write (line 175) | pub fn write(&mut self, _content: Content, callback: impl FnOnce(Resul...
  type State (line 25) | enum State {
  function to_error (line 138) | fn to_error(error: arboard::Error) -> Error {
  type Clipboard (line 161) | pub struct Clipboard;
    method new (line 34) | pub fn new() -> Self {
    method read (line 48) | pub fn read(
    method write (line 95) | pub fn write(
    method new (line 165) | pub fn new() -> Self {
    method read (line 170) | pub fn read(&self, _kind: Kind, callback: impl FnOnce(Result<Content, ...
    method write (line 175) | pub fn write(&mut self, _content: Content, callback: impl FnOnce(Resul...

FILE: winit/src/conversion.rs
  function window_attributes (line 14) | pub fn window_attributes(
  function window_event (line 149) | pub fn window_event(
  function window_level (line 315) | pub fn window_level(level: window::Level) -> winit::window::WindowLevel {
  function position (line 326) | pub fn position(
  function fullscreen (line 393) | pub fn fullscreen(
  function visible (line 404) | pub fn visible(mode: window::Mode) -> bool {
  function mode (line 414) | pub fn mode(mode: Option<winit::window::Fullscreen>) -> window::Mode {
  function theme_mode (line 424) | pub fn theme_mode(theme: winit::window::Theme) -> theme::Mode {
  function window_theme (line 434) | pub fn window_theme(mode: theme::Mode) -> Option<winit::window::Theme> {
  function mouse_interaction (line 445) | pub fn mouse_interaction(interaction: mouse::Interaction) -> Option<wini...
  function mouse_button (line 486) | pub fn mouse_button(mouse_button: winit::event::MouseButton) -> mouse::B...
  function modifiers (line 502) | pub fn modifiers(modifiers: winit::keyboard::ModifiersState) -> keyboard...
  function cursor_position (line 514) | pub fn cursor_position(position: winit::dpi::PhysicalPosition<f64>, scal...
  function touch_event (line 524) | pub fn touch_event(touch: winit::event::Touch, scale_factor: f32) -> tou...
  function key (line 544) | pub fn key(key: winit::keyboard::Key) -> keyboard::Key {
  function physical_key (line 867) | pub fn physical_key(physical_key: winit::keyboard::PhysicalKey) -> keybo...
  function key_code (line 884) | pub fn key_code(key_code: winit::keyboard::KeyCode) -> Option<keyboard::...
  function native_key_code (line 1090) | pub fn native_key_code(
  function user_attention (line 1107) | pub fn user_attention(user_attention: window::UserAttention) -> winit::w...
  function resize_direction (line 1115) | pub fn resize_direction(resize_direction: window::Direction) -> winit::w...
  function icon (line 1131) | pub fn icon(icon: window::Icon) -> Option<winit::window::Icon> {
  function ime_purpose (line 1138) | pub fn ime_purpose(purpose: input_method::Purpose) -> winit::window::Ime...
  function is_private_use (line 1147) | fn is_private_use(c: char) -> bool {

FILE: winit/src/error.rs
  type Error (line 6) | pub enum Error {
    method from (line 21) | fn from(error: graphics::Error) -> Error {

FILE: winit/src/lib.rs
  function run (line 69) | pub fn run<P>(program: P) -> Result<(), Error>
  type Event (line 443) | enum Event<Message: 'static> {
  type Control (line 456) | enum Control {
  function run_instance (line 471) | async fn run_instance<P>(
  function build_user_interface (line 1196) | fn build_user_interface<'a, P: Program>(
  function update (line 1217) | fn update<P: Program, E: Executor>(
  function run_action (line 1270) | fn run_action<'a, P, C>(
  function build_user_interfaces (line 1742) | pub fn build_user_interfaces<'a, P: Program, C>(
  function user_force_quit (line 1785) | pub fn user_force_quit(
  function system_information (line 1805) | fn system_information(graphics: compositor::Information) -> system::Info...
  function run_clipboard (line 1836) | fn run_clipboard<Message: Send>(

FILE: winit/src/proxy.rs
  type Proxy (line 14) | pub struct Proxy<T: 'static> {
  method clone (line 21) | fn clone(&self) -> Self {
  constant MAX_SIZE (line 31) | const MAX_SIZE: usize = 100;
  function new (line 34) | pub fn new(
  function send (line 82) | pub fn send(&self, value: T) {
  function send_action (line 90) | pub fn send_action(&self, action: Action<T>) {
  function free_slots (line 96) | pub fn free_slots(&mut self, amount: usize) {
  type Error (line 102) | type Error = mpsc::SendError;
  function poll_ready (line 104) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function start_send (line 108) | fn start_send(mut self: Pin<&mut Self>, action: Action<T>) -> Result<(),...
  function poll_flush (line 112) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  function poll_close (line 122) | fn poll_close(
  function tick (line 135) | fn tick(&self) {
  function request_redraw (line 139) | fn request_redraw(&self) {
  function invalidate_layout (line 143) | fn invalidate_layout(&self) {

FILE: winit/src/window.rs
  type WindowManager (line 26) | pub struct WindowManager<P, C>
  function new (line 42) | pub fn new() -> Self {
  function insert (line 49) | pub fn insert(
  function is_empty (line 89) | pub fn is_empty(&self) -> bool {
  function is_idle (line 93) | pub fn is_idle(&self) -> bool {
  function redraw_at (line 99) | pub fn redraw_at(&self) -> Option<Instant> {
  function first (line 106) | pub fn first(&self) -> Option<&Window<P, C>> {
  function iter_mut (line 110) | pub fn iter_mut(&mut self) -> impl Iterator<Item = (Id, &mut Window<P, C...
  function get (line 114) | pub fn get(&self, id: Id) -> Option<&Window<P, C>> {
  function get_mut (line 118) | pub fn get_mut(&mut self, id: Id) -> Option<&mut Window<P, C>> {
  function get_mut_alias (line 122) | pub fn get_mut_alias(
  function last_monitor (line 131) | pub fn last_monitor(&self) -> Option<MonitorHandle> {
  function remove (line 135) | pub fn remove(&mut self, id: Id) -> Option<Window<P, C>> {
  method default (line 149) | fn default() -> Self {
  type Window (line 154) | pub struct Window<P, C>
  function position (line 178) | pub fn position(&self) -> Option<Point> {
  function request_redraw (line 189) | pub fn request_redraw(&mut self, redraw_request: RedrawRequest) {
  function request_input_method (line 202) | pub fn request_input_method(&mut self, input_method: InputMethod) {
  function update_mouse (line 236) | pub fn update_mouse(&mut self, interaction: mouse::Interaction) {
  function draw_preedit (line 252) | pub fn draw_preedit(&mut self) {
  function enable_ime (line 263) | fn enable_ime(&mut self, cursor: Rectangle, purpose: input_method::Purpo...
  function disable_ime (line 279) | fn disable_ime(&mut self) {
  function window_handle (line 294) | fn window_handle(
  function display_handle (line 306) | fn display_handle(
  type Preedit (line 313) | struct Preedit<Renderer>
  function new (line 326) | fn new() -> Self {
  function update (line 334) | fn update(
  function draw (line 387) | fn draw(&self, renderer: &mut Renderer, color: Color, background: Color,...

FILE: winit/src/window/state.rs
  type State (line 13) | pub struct State<P: Program>
  method fmt (line 33) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function new (line 49) | pub fn new(
  function viewport (line 85) | pub fn viewport(&self) -> &Viewport {
  function surface_version (line 89) | pub fn surface_version(&self) -> u64 {
  function physical_size (line 93) | pub fn physical_size(&self) -> Size<u32> {
  function logical_size (line 97) | pub fn logical_size(&self) -> Size<f32> {
  function scale_factor (line 101) | pub fn scale_factor(&self) -> f32 {
  function cursor (line 105) | pub fn cursor(&self) -> mouse::Cursor {
  function modifiers (line 114) | pub fn modifiers(&self) -> winit::keyboard::ModifiersState {
  function theme (line 118) | pub fn theme(&self) -> &P::Theme {
  function theme_mode (line 122) | pub fn theme_mode(&self) -> theme::Mode {
  function background_color (line 126) | pub fn background_color(&self) -> Color {
  function text_color (line 130) | pub fn text_color(&self) -> Color {
  function update (line 134) | pub fn update(&mut self, program: &program::Instance<P>, window: &Window...
  function synchronize (line 182) | pub fn synchronize(