Full Code of iced-rs/iced for AI

gitextract_lpzyxa4s/

├── .cargo/
│   └── config.toml
├── .github/
│   ├── FUNDING.yml
│   ├── ISSUE_TEMPLATE/
│   │   ├── BUG-REPORT.yml
│   │   └── config.yml
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       ├── audit.yml
│       ├── build.yml
│       ├── check.yml
│       ├── document.yml
│       ├── format.yml
│       ├── lint.yml
│       └── test.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── Cross.toml
├── DEPENDENCIES.md
├── LICENSE
├── README.md
├── ROADMAP.md
├── beacon/
│   ├── Cargo.toml
│   └── src/
│       ├── client.rs
│       ├── error.rs
│       ├── lib.rs
│       ├── span.rs
│       └── stream.rs
├── benches/
│   ├── ipsum.txt
│   └── wgpu.rs
├── clippy.toml
├── core/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── alignment.rs
│       ├── angle.rs
│       ├── animation.rs
│       ├── background.rs
│       ├── border.rs
│       ├── clipboard.rs
│       ├── color.rs
│       ├── content_fit.rs
│       ├── element.rs
│       ├── event.rs
│       ├── font.rs
│       ├── gradient.rs
│       ├── image.rs
│       ├── input_method.rs
│       ├── keyboard/
│       │   ├── event.rs
│       │   ├── key.rs
│       │   ├── location.rs
│       │   └── modifiers.rs
│       ├── keyboard.rs
│       ├── layout/
│       │   ├── DRUID_LICENSE
│       │   ├── flex.rs
│       │   ├── limits.rs
│       │   └── node.rs
│       ├── layout.rs
│       ├── length.rs
│       ├── lib.rs
│       ├── mouse/
│       │   ├── button.rs
│       │   ├── click.rs
│       │   ├── cursor.rs
│       │   ├── event.rs
│       │   └── interaction.rs
│       ├── mouse.rs
│       ├── overlay/
│       │   ├── element.rs
│       │   ├── group.rs
│       │   └── nested.rs
│       ├── overlay.rs
│       ├── padding.rs
│       ├── pixels.rs
│       ├── point.rs
│       ├── rectangle.rs
│       ├── renderer/
│       │   └── null.rs
│       ├── renderer.rs
│       ├── rotation.rs
│       ├── settings.rs
│       ├── shadow.rs
│       ├── shell.rs
│       ├── size.rs
│       ├── svg.rs
│       ├── text/
│       │   ├── editor.rs
│       │   ├── highlighter.rs
│       │   └── paragraph.rs
│       ├── text.rs
│       ├── theme/
│       │   └── palette.rs
│       ├── theme.rs
│       ├── time.rs
│       ├── touch.rs
│       ├── transformation.rs
│       ├── vector.rs
│       ├── widget/
│       │   ├── id.rs
│       │   ├── operation/
│       │   │   ├── focusable.rs
│       │   │   ├── scrollable.rs
│       │   │   └── text_input.rs
│       │   ├── operation.rs
│       │   ├── text.rs
│       │   └── tree.rs
│       ├── widget.rs
│       ├── window/
│       │   ├── direction.rs
│       │   ├── event.rs
│       │   ├── icon.rs
│       │   ├── id.rs
│       │   ├── level.rs
│       │   ├── mode.rs
│       │   ├── position.rs
│       │   ├── redraw_request.rs
│       │   ├── screenshot.rs
│       │   ├── settings/
│       │   │   ├── linux.rs
│       │   │   ├── macos.rs
│       │   │   ├── other.rs
│       │   │   ├── wasm.rs
│       │   │   └── windows.rs
│       │   ├── settings.rs
│       │   └── user_attention.rs
│       └── window.rs
├── debug/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── devtools/
│   ├── Cargo.toml
│   └── src/
│       ├── comet.rs
│       ├── lib.rs
│       └── time_machine.rs
├── docs/
│   ├── redirect.html
│   └── release_summary.py
├── examples/
│   ├── README.md
│   ├── arc/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── bezier_tool/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── changelog/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── changelog.rs
│   │       ├── icon.rs
│   │       └── main.rs
│   ├── checkbox/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── clock/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── color_palette/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── combo_box/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── counter/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── index.html
│   │   └── src/
│   │       └── main.rs
│   ├── custom_quad/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── custom_shader/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── main.rs
│   │       ├── scene/
│   │       │   ├── camera.rs
│   │       │   ├── pipeline/
│   │       │   │   ├── buffer.rs
│   │       │   │   ├── cube.rs
│   │       │   │   ├── uniforms.rs
│   │       │   │   └── vertex.rs
│   │       │   └── pipeline.rs
│   │       ├── scene.rs
│   │       └── shaders/
│   │           ├── cubes.wgsl
│   │           └── depth.wgsl
│   ├── custom_widget/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── delineate/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── download_progress/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── index.html
│   │   └── src/
│   │       ├── download.rs
│   │       └── main.rs
│   ├── editor/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── events/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── exit/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── ferris/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── gallery/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── civitai.rs
│   │       └── main.rs
│   ├── game_of_life/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── main.rs
│   │       └── preset.rs
│   ├── geometry/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── gradient/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── integration/
│   │   ├── .gitignore
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── controls.rs
│   │       ├── main.rs
│   │       ├── scene.rs
│   │       └── shader/
│   │           ├── frag.wgsl
│   │           └── vert.wgsl
│   ├── layout/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── lazy/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── loading_spinners/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── circular.rs
│   │       ├── easing.rs
│   │       ├── linear.rs
│   │       └── main.rs
│   ├── loupe/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── markdown/
│   │   ├── Cargo.toml
│   │   ├── build.rs
│   │   ├── fonts/
│   │   │   └── markdown-icons.toml
│   │   ├── overview.md
│   │   └── src/
│   │       ├── icon.rs
│   │       └── main.rs
│   ├── modal/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── multi_window/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── multitouch/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── pane_grid/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── pick_list/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── pokedex/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── progress_bar/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── qr_code/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── sandpiles/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── screenshot/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── scrollable/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── sierpinski_triangle/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── slider/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── solar_system/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── stopwatch/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── styling/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── snapshots/
│   │   │   ├── catppuccin_frappé-tiny-skia.sha256
│   │   │   ├── catppuccin_latte-tiny-skia.sha256
│   │   │   ├── catppuccin_macchiato-tiny-skia.sha256
│   │   │   ├── catppuccin_mocha-tiny-skia.sha256
│   │   │   ├── dark-tiny-skia.sha256
│   │   │   ├── dracula-tiny-skia.sha256
│   │   │   ├── ferra-tiny-skia.sha256
│   │   │   ├── gruvbox_dark-tiny-skia.sha256
│   │   │   ├── gruvbox_light-tiny-skia.sha256
│   │   │   ├── kanagawa_dragon-tiny-skia.sha256
│   │   │   ├── kanagawa_lotus-tiny-skia.sha256
│   │   │   ├── kanagawa_wave-tiny-skia.sha256
│   │   │   ├── light-tiny-skia.sha256
│   │   │   ├── moonfly-tiny-skia.sha256
│   │   │   ├── nightfly-tiny-skia.sha256
│   │   │   ├── nord-tiny-skia.sha256
│   │   │   ├── oxocarbon-tiny-skia.sha256
│   │   │   ├── solarized_dark-tiny-skia.sha256
│   │   │   ├── solarized_light-tiny-skia.sha256
│   │   │   ├── tokyo_night-tiny-skia.sha256
│   │   │   ├── tokyo_night_light-tiny-skia.sha256
│   │   │   └── tokyo_night_storm-tiny-skia.sha256
│   │   └── src/
│   │       └── main.rs
│   ├── svg/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── system_information/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── table/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── text/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── the_matrix/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── toast/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── todos/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── iced-todos.desktop
│   │   ├── index.html
│   │   ├── snapshots/
│   │   │   └── creates_a_new_task-tiny-skia.sha256
│   │   ├── src/
│   │   │   └── main.rs
│   │   └── tests/
│   │       └── carl_sagan.ice
│   ├── tooltip/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── tour/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── index.html
│   │   └── src/
│   │       └── main.rs
│   ├── url_handler/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── vectorial_text/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   └── websocket/
│       ├── Cargo.toml
│       ├── README.md
│       └── src/
│           ├── echo/
│           │   └── server.rs
│           ├── echo.rs
│           └── main.rs
├── futures/
│   ├── Cargo.toml
│   └── src/
│       ├── backend/
│       │   ├── default.rs
│       │   ├── native/
│       │   │   ├── smol.rs
│       │   │   ├── thread_pool.rs
│       │   │   └── tokio.rs
│       │   ├── native.rs
│       │   ├── null.rs
│       │   ├── wasm/
│       │   │   └── wasm_bindgen.rs
│       │   └── wasm.rs
│       ├── backend.rs
│       ├── event.rs
│       ├── executor.rs
│       ├── keyboard.rs
│       ├── lib.rs
│       ├── maybe.rs
│       ├── runtime.rs
│       ├── stream.rs
│       ├── subscription/
│       │   └── tracker.rs
│       └── subscription.rs
├── graphics/
│   ├── Cargo.toml
│   └── src/
│       ├── antialiasing.rs
│       ├── cache.rs
│       ├── color.rs
│       ├── compositor.rs
│       ├── damage.rs
│       ├── error.rs
│       ├── geometry/
│       │   ├── cache.rs
│       │   ├── fill.rs
│       │   ├── frame.rs
│       │   ├── path/
│       │   │   ├── arc.rs
│       │   │   └── builder.rs
│       │   ├── path.rs
│       │   ├── stroke.rs
│       │   ├── style.rs
│       │   └── text.rs
│       ├── geometry.rs
│       ├── gradient.rs
│       ├── image/
│       │   └── storage.rs
│       ├── image.rs
│       ├── layer.rs
│       ├── lib.rs
│       ├── mesh.rs
│       ├── shell.rs
│       ├── text/
│       │   ├── cache.rs
│       │   ├── editor.rs
│       │   └── paragraph.rs
│       ├── text.rs
│       └── viewport.rs
├── highlighter/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── program/
│   ├── Cargo.toml
│   └── src/
│       ├── lib.rs
│       ├── message.rs
│       └── preset.rs
├── renderer/
│   ├── Cargo.toml
│   └── src/
│       ├── fallback.rs
│       └── lib.rs
├── runtime/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── clipboard.rs
│       ├── font.rs
│       ├── image.rs
│       ├── keyboard.rs
│       ├── lib.rs
│       ├── system.rs
│       ├── task.rs
│       ├── user_interface.rs
│       ├── widget/
│       │   ├── operation.rs
│       │   └── selector.rs
│       ├── widget.rs
│       └── window.rs
├── selector/
│   ├── Cargo.toml
│   └── src/
│       ├── find.rs
│       ├── lib.rs
│       └── target.rs
├── src/
│   ├── advanced.rs
│   ├── application/
│   │   └── timed.rs
│   ├── application.rs
│   ├── daemon.rs
│   ├── error.rs
│   ├── lib.rs
│   ├── time.rs
│   ├── touch.rs
│   ├── window/
│   │   └── icon.rs
│   └── window.rs
├── test/
│   ├── Cargo.toml
│   └── src/
│       ├── emulator.rs
│       ├── error.rs
│       ├── ice.rs
│       ├── instruction.rs
│       ├── lib.rs
│       └── simulator.rs
├── tester/
│   ├── Cargo.toml
│   ├── fonts/
│   │   └── iced_tester-icons.toml
│   └── src/
│       ├── icon.rs
│       ├── lib.rs
│       └── recorder.rs
├── tiny_skia/
│   ├── Cargo.toml
│   └── src/
│       ├── engine.rs
│       ├── geometry.rs
│       ├── layer.rs
│       ├── lib.rs
│       ├── primitive.rs
│       ├── raster.rs
│       ├── text.rs
│       ├── vector.rs
│       ├── window/
│       │   └── compositor.rs
│       └── window.rs
├── wgpu/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── buffer.rs
│       ├── color.rs
│       ├── engine.rs
│       ├── geometry.rs
│       ├── image/
│       │   ├── atlas/
│       │   │   ├── allocation.rs
│       │   │   ├── allocator.rs
│       │   │   ├── entry.rs
│       │   │   └── layer.rs
│       │   ├── atlas.rs
│       │   ├── cache.rs
│       │   ├── mod.rs
│       │   ├── null.rs
│       │   ├── raster.rs
│       │   └── vector.rs
│       ├── layer.rs
│       ├── lib.rs
│       ├── primitive.rs
│       ├── quad/
│       │   ├── gradient.rs
│       │   └── solid.rs
│       ├── quad.rs
│       ├── shader/
│       │   ├── blit.wgsl
│       │   ├── color/
│       │   │   └── linear_rgb.wgsl
│       │   ├── color.wgsl
│       │   ├── image.wgsl
│       │   ├── quad/
│       │   │   ├── gradient.wgsl
│       │   │   └── solid.wgsl
│       │   ├── quad.wgsl
│       │   ├── triangle/
│       │   │   ├── gradient.wgsl
│       │   │   └── solid.wgsl
│       │   ├── triangle.wgsl
│       │   └── vertex.wgsl
│       ├── text.rs
│       ├── triangle/
│       │   └── msaa.rs
│       ├── triangle.rs
│       ├── window/
│       │   └── compositor.rs
│       └── window.rs
├── widget/
│   ├── Cargo.toml
│   └── src/
│       ├── action.rs
│       ├── button.rs
│       ├── canvas/
│       │   └── program.rs
│       ├── canvas.rs
│       ├── checkbox.rs
│       ├── column.rs
│       ├── combo_box.rs
│       ├── container.rs
│       ├── float.rs
│       ├── grid.rs
│       ├── helpers.rs
│       ├── image/
│       │   └── viewer.rs
│       ├── image.rs
│       ├── keyed/
│       │   └── column.rs
│       ├── keyed.rs
│       ├── lazy/
│       │   ├── cache.rs
│       │   ├── component.rs
│       │   └── helpers.rs
│       ├── lazy.rs
│       ├── lib.rs
│       ├── markdown.rs
│       ├── mouse_area.rs
│       ├── overlay/
│       │   └── menu.rs
│       ├── overlay.rs
│       ├── pane_grid/
│       │   ├── axis.rs
│       │   ├── configuration.rs
│       │   ├── content.rs
│       │   ├── controls.rs
│       │   ├── direction.rs
│       │   ├── draggable.rs
│       │   ├── node.rs
│       │   ├── pane.rs
│       │   ├── split.rs
│       │   ├── state.rs
│       │   └── title_bar.rs
│       ├── pane_grid.rs
│       ├── pick_list.rs
│       ├── pin.rs
│       ├── progress_bar.rs
│       ├── qr_code.rs
│       ├── radio.rs
│       ├── responsive.rs
│       ├── row.rs
│       ├── rule.rs
│       ├── scrollable.rs
│       ├── sensor.rs
│       ├── shader/
│       │   └── program.rs
│       ├── shader.rs
│       ├── slider.rs
│       ├── space.rs
│       ├── stack.rs
│       ├── svg.rs
│       ├── table.rs
│       ├── text/
│       │   └── rich.rs
│       ├── text.rs
│       ├── text_editor.rs
│       ├── text_input/
│       │   ├── cursor.rs
│       │   ├── editor.rs
│       │   └── value.rs
│       ├── text_input.rs
│       ├── themer.rs
│       ├── toggler.rs
│       ├── tooltip.rs
│       └── vertical_slider.rs
└── winit/
    ├── Cargo.toml
    ├── README.md
    └── src/
        ├── clipboard.rs
        ├── conversion.rs
        ├── error.rs
        ├── lib.rs
        ├── proxy.rs
        ├── window/
        │   └── state.rs
        └── window.rs

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

[
  {
    "path": ".cargo/config.toml",
    "chars": 188,
    "preview": "[alias]\nlint = \"clippy --workspace --benches --all-features --no-deps -- -D warnings\"\nlint-fix = \"clippy --fix --allow-d"
  },
  {
    "path": ".github/FUNDING.yml",
    "chars": 28,
    "preview": "github: hecrj\nko_fi: hecrj_\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/BUG-REPORT.yml",
    "chars": 3857,
    "preview": "name: I have a problem with the library\ndescription: File a bug report.\nlabels: [\"bug\"]\nbody:\n  - type: markdown\n    att"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 571,
    "preview": "blank_issues_enabled: false\ncontact_links:\n  - name: I have a question\n    url: https://iced.zulipchat.com/#narrow/chann"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 482,
    "preview": "The core team is busy and does not have time to mentor nor babysit new contributors. If a member of the core team thinks"
  },
  {
    "path": ".github/workflows/audit.yml",
    "chars": 867,
    "preview": "name: Audit\non:\n  push: {}\n  pull_request: {}\n  schedule:\n    - cron: '0 0 * * *'\njobs:\n  vulnerabilities:\n    runs-on: "
  },
  {
    "path": ".github/workflows/build.yml",
    "chars": 3338,
    "preview": "name: Build\non:\n  push:\n    branches:\n      - master\njobs:\n  todos_linux:\n    runs-on: ubuntu-latest\n    steps:\n    - us"
  },
  {
    "path": ".github/workflows/check.yml",
    "chars": 876,
    "preview": "name: Check\non: [push, pull_request]\njobs:\n  wasm:\n    runs-on: ubuntu-latest\n    env:\n      RUSTFLAGS: --cfg=web_sys_un"
  },
  {
    "path": ".github/workflows/document.yml",
    "chars": 1291,
    "preview": "name: Document\non: [push, pull_request]\njobs:\n  all:\n    runs-on: ubuntu-latest\n    concurrency:\n      group: ${{ github"
  },
  {
    "path": ".github/workflows/format.yml",
    "chars": 277,
    "preview": "name: Format\non: [push, pull_request]\njobs:\n  all:\n    runs-on: ubuntu-latest\n    steps:\n    - uses: hecrj/setup-rust-ac"
  },
  {
    "path": ".github/workflows/lint.yml",
    "chars": 432,
    "preview": "name: Lint\non: [push, pull_request]\njobs:\n  all:\n    runs-on: ubuntu-latest\n    steps:\n    - uses: hecrj/setup-rust-acti"
  },
  {
    "path": ".github/workflows/test.yml",
    "chars": 828,
    "preview": "name: Test\non: [push, pull_request]\njobs:\n  all:\n    runs-on: ${{ matrix.os }}\n    env:\n      RUSTFLAGS: --deny warnings"
  },
  {
    "path": ".gitignore",
    "chars": 38,
    "preview": "target/\npkg/\n**/*.rs.bk\ndist/\ntraces/\n"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 86972,
    "preview": "# Changelog\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Changel"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 1726,
    "preview": "# Contributing\n\nThank you for considering contributing to Iced! Take a look at [the roadmap] to get an idea of the curre"
  },
  {
    "path": "Cargo.toml",
    "chars": 8843,
    "preview": "[package]\nname = \"iced\"\ndescription = \"A cross-platform GUI library inspired by Elm\"\nversion.workspace = true\nedition.wo"
  },
  {
    "path": "Cross.toml",
    "chars": 183,
    "preview": "[target.aarch64-unknown-linux-gnu]\nimage = \"ghcr.io/iced-rs/aarch64:latest\"\nxargo = false\n\n[target.armv7-unknown-linux-g"
  },
  {
    "path": "DEPENDENCIES.md",
    "chars": 2010,
    "preview": "# Dependencies\n\nIced requires some system dependencies to work, and not\nall operating systems come with them installed.\n"
  },
  {
    "path": "LICENSE",
    "chars": 1071,
    "preview": "Copyright 2019 Héctor Ramón, Iced contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a "
  },
  {
    "path": "README.md",
    "chars": 7203,
    "preview": "<div align=\"center\">\n\n<img src=\"docs/logo.svg\" width=\"140px\" />\n\n# Iced\n\n[![Documentation](https://docs.rs/iced/badge.sv"
  },
  {
    "path": "ROADMAP.md",
    "chars": 113,
    "preview": "# Roadmap\nWe have [a detailed graphical roadmap now](https://whimsical.com/roadmap-iced-7vhq6R35Lp3TmYH4WeYwLM)!\n"
  },
  {
    "path": "beacon/Cargo.toml",
    "chars": 712,
    "preview": "[package]\nname = \"iced_beacon\"\ndescription = \"A client/server protocol to monitor and supervise iced applications\"\nversi"
  },
  {
    "path": "beacon/src/client.rs",
    "chars": 7718,
    "preview": "use crate::Error;\nuse crate::core::theme::palette;\nuse crate::core::time::{Duration, SystemTime};\nuse crate::span;\n\nuse "
  },
  {
    "path": "beacon/src/error.rs",
    "chars": 242,
    "preview": "use std::io;\n\n#[derive(Debug, thiserror::Error)]\npub enum Error {\n    #[error(\"input/output operation failed: {0}\")]\n   "
  },
  {
    "path": "beacon/src/lib.rs",
    "chars": 11916,
    "preview": "pub use iced_core as core;\npub use semver::Version;\n\npub mod client;\npub mod span;\n\nmod error;\nmod stream;\n\npub use clie"
  },
  {
    "path": "beacon/src/span.rs",
    "chars": 2106,
    "preview": "use crate::core::window;\n\nuse serde::{Deserialize, Serialize};\n\n#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, H"
  },
  {
    "path": "beacon/src/stream.rs",
    "chars": 372,
    "preview": "use futures::Future;\nuse futures::channel::mpsc;\nuse futures::stream::{self, Stream, StreamExt};\n\npub fn channel<T, F>(f"
  },
  {
    "path": "benches/ipsum.txt",
    "chars": 2962,
    "preview": "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur at elit mollis, dictum nunc non, tempus metus. Sed ia"
  },
  {
    "path": "benches/wgpu.rs",
    "chars": 7502,
    "preview": "#![allow(missing_docs)]\nuse criterion::{Bencher, Criterion, criterion_group, criterion_main};\n\nuse iced::alignment;\nuse "
  },
  {
    "path": "clippy.toml",
    "chars": 67,
    "preview": "too-many-arguments-threshold = 20\nenum-variant-name-threshold = 10\n"
  },
  {
    "path": "core/Cargo.toml",
    "chars": 735,
    "preview": "[package]\nname = \"iced_core\"\ndescription = \"The essential ideas of iced\"\nversion.workspace = true\nedition.workspace = tr"
  },
  {
    "path": "core/README.md",
    "chars": 811,
    "preview": "# `iced_core`\n[![Documentation](https://docs.rs/iced_core/badge.svg)][documentation]\n[![Crates.io](https://img.shields.i"
  },
  {
    "path": "core/src/alignment.rs",
    "chars": 1798,
    "preview": "//! Align and position widgets.\n\n/// Alignment on the axis of a container.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, H"
  },
  {
    "path": "core/src/angle.rs",
    "chars": 5013,
    "preview": "use crate::{Point, Rectangle, Vector};\n\nuse std::f32::consts::{FRAC_PI_2, PI};\nuse std::fmt::Display;\nuse std::ops::{Add"
  },
  {
    "path": "core/src/animation.rs",
    "chars": 4615,
    "preview": "//! Animate your applications.\nuse crate::time::{Duration, Instant};\n\npub use lilt::{Easing, FloatRepresentable as Float"
  },
  {
    "path": "core/src/background.rs",
    "chars": 1062,
    "preview": "use crate::Color;\nuse crate::gradient::{self, Gradient};\n\n/// The background of some element.\n#[derive(Debug, Clone, Cop"
  },
  {
    "path": "core/src/border.rs",
    "chars": 7032,
    "preview": "//! Draw lines around containers.\nuse crate::{Color, Pixels};\n\n/// A border.\n#[derive(Debug, Clone, Copy, PartialEq, Def"
  },
  {
    "path": "core/src/clipboard.rs",
    "chars": 3141,
    "preview": "//! Access the clipboard.\nuse std::path::PathBuf;\nuse std::sync::Arc;\n\n/// A set of clipboard requests.\n#[derive(Debug, "
  },
  {
    "path": "core/src/color.rs",
    "chars": 11462,
    "preview": "use crate::animation::Interpolable;\n\n/// A color in the `sRGB` color space.\n///\n/// # String Representation\n///\n/// A co"
  },
  {
    "path": "core/src/content_fit.rs",
    "chars": 5149,
    "preview": "//! Control the fit of some content (like an image) within a space.\nuse crate::Size;\n\nuse std::fmt;\n\n/// The strategy us"
  },
  {
    "path": "core/src/element.rs",
    "chars": 15390,
    "preview": "use crate::layout;\nuse crate::mouse;\nuse crate::overlay;\nuse crate::renderer;\nuse crate::widget;\nuse crate::widget::tree"
  },
  {
    "path": "core/src/event.rs",
    "chars": 1731,
    "preview": "//! Handle events of a user interface.\nuse crate::clipboard;\nuse crate::input_method;\nuse crate::keyboard;\nuse crate::mo"
  },
  {
    "path": "core/src/font.rs",
    "chars": 5096,
    "preview": "//! Load and use fonts.\nuse std::hash::Hash;\n\n/// A font.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]\npu"
  },
  {
    "path": "core/src/gradient.rs",
    "chars": 3086,
    "preview": "//! Colors that transition progressively.\nuse crate::{Color, Radians};\n\nuse std::cmp::Ordering;\n\n#[derive(Debug, Clone, "
  },
  {
    "path": "core/src/image.rs",
    "chars": 10078,
    "preview": "//! Load and draw raster graphics.\nuse crate::border;\nuse crate::{Bytes, Radians, Rectangle, Size};\n\nuse rustc_hash::FxH"
  },
  {
    "path": "core/src/input_method.rs",
    "chars": 6232,
    "preview": "//! Listen to input method events.\nuse crate::{Pixels, Rectangle};\n\nuse std::ops::Range;\n\n/// The input method strategy "
  },
  {
    "path": "core/src/keyboard/event.rs",
    "chars": 1507,
    "preview": "use crate::SmolStr;\nuse crate::keyboard::key;\nuse crate::keyboard::{Key, Location, Modifiers};\n\n/// A keyboard event.\n//"
  },
  {
    "path": "core/src/keyboard/key.rs",
    "chars": 51008,
    "preview": "//! Identify keyboard keys.\nuse crate::SmolStr;\n\n/// A key on the keyboard.\n///\n/// This is mostly the `Key` type found "
  },
  {
    "path": "core/src/keyboard/location.rs",
    "chars": 324,
    "preview": "/// The location of a key on the keyboard.\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum Location {\n    /// The "
  },
  {
    "path": "core/src/keyboard/modifiers.rs",
    "chars": 3286,
    "preview": "use bitflags::bitflags;\n\nbitflags! {\n    /// The current state of the keyboard modifiers.\n    #[derive(Debug, Clone, Cop"
  },
  {
    "path": "core/src/keyboard.rs",
    "chars": 184,
    "preview": "//! Listen to keyboard events.\npub mod key;\n\nmod event;\nmod location;\nmod modifiers;\n\npub use event::Event;\npub use key:"
  },
  {
    "path": "core/src/layout/DRUID_LICENSE",
    "chars": 11358,
    "preview": "\n                                 Apache License\n                           Version 2.0, January 2004\n                  "
  },
  {
    "path": "core/src/layout/flex.rs",
    "chars": 9739,
    "preview": "//! Distribute elements using a flex-based layout.\n// This code is heavily inspired by the [`druid`] codebase.\n//\n// [`d"
  },
  {
    "path": "core/src/layout/limits.rs",
    "chars": 5307,
    "preview": "#![allow(clippy::manual_clamp)]\nuse crate::{Length, Size};\n\n/// A set of size constraints for layouting.\n#[derive(Debug,"
  },
  {
    "path": "core/src/layout/node.rs",
    "chars": 3187,
    "preview": "use crate::{Alignment, Padding, Point, Rectangle, Size, Vector};\n\n/// The bounds of an element and its children.\n#[deriv"
  },
  {
    "path": "core/src/layout.rs",
    "chars": 5884,
    "preview": "//! Position your widgets properly.\nmod limits;\nmod node;\n\npub mod flex;\n\npub use limits::Limits;\npub use node::Node;\n\nu"
  },
  {
    "path": "core/src/length.rs",
    "chars": 2401,
    "preview": "use crate::Pixels;\n\n/// The strategy used to fill space in a specific dimension.\n#[derive(Debug, Clone, Copy, PartialEq)"
  },
  {
    "path": "core/src/lib.rs",
    "chars": 4104,
    "preview": "//! The core library of [Iced].\n//!\n//! This library holds basic types that can be reused and re-exported in\n//! differe"
  },
  {
    "path": "core/src/mouse/button.rs",
    "chars": 365,
    "preview": "/// The button of a mouse.\n#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]\npub enum Button {\n    /// The left mouse b"
  },
  {
    "path": "core/src/mouse/click.rs",
    "chars": 2215,
    "preview": "//! Track mouse clicks.\nuse crate::mouse::Button;\nuse crate::time::Instant;\nuse crate::{Point, Transformation};\n\nuse std"
  },
  {
    "path": "core/src/mouse/cursor.rs",
    "chars": 3631,
    "preview": "use crate::{Point, Rectangle, Transformation, Vector};\n\n/// The mouse cursor state.\n#[derive(Debug, Clone, Copy, Partial"
  },
  {
    "path": "core/src/mouse/event.rs",
    "chars": 1323,
    "preview": "use crate::Point;\n\nuse super::Button;\n\n/// A mouse event.\n///\n/// _**Note:** This type is largely incomplete! If you nee"
  },
  {
    "path": "core/src/mouse/interaction.rs",
    "chars": 568,
    "preview": "/// The interaction of a mouse cursor.\n#[derive(Debug, Eq, PartialEq, Clone, Copy, PartialOrd, Ord, Default)]\n#[allow(mi"
  },
  {
    "path": "core/src/mouse.rs",
    "chars": 235,
    "preview": "//! Handle mouse events.\npub mod click;\n\nmod button;\nmod cursor;\nmod event;\nmod interaction;\n\npub use button::Button;\npu"
  },
  {
    "path": "core/src/overlay/element.rs",
    "chars": 3378,
    "preview": "pub use crate::Overlay;\n\nuse crate::layout;\nuse crate::mouse;\nuse crate::renderer;\nuse crate::widget;\nuse crate::{Event,"
  },
  {
    "path": "core/src/overlay/group.rs",
    "chars": 4611,
    "preview": "use crate::layout;\nuse crate::mouse;\nuse crate::overlay;\nuse crate::renderer;\nuse crate::widget;\nuse crate::{Event, Layo"
  },
  {
    "path": "core/src/overlay/nested.rs",
    "chars": 8660,
    "preview": "use crate::event;\nuse crate::layout;\nuse crate::mouse;\nuse crate::overlay;\nuse crate::renderer;\nuse crate::widget;\nuse c"
  },
  {
    "path": "core/src/overlay.rs",
    "chars": 3286,
    "preview": "//! Display interactive elements on top of other widgets.\nmod element;\nmod group;\nmod nested;\n\npub use element::Element;"
  },
  {
    "path": "core/src/padding.rs",
    "chars": 6067,
    "preview": "//! Space stuff around the perimeter.\nuse crate::{Pixels, Size};\n\n/// An amount of space to pad for each side of a box\n/"
  },
  {
    "path": "core/src/pixels.rs",
    "chars": 1784,
    "preview": "/// An amount of logical pixels.\n///\n/// Normally used to represent an amount of space, or the size of something.\n///\n//"
  },
  {
    "path": "core/src/point.rs",
    "chars": 2850,
    "preview": "use crate::Vector;\n\nuse num_traits::{Float, Num};\nuse std::fmt;\n\n/// A 2D point.\n#[derive(Debug, Clone, Copy, PartialEq,"
  },
  {
    "path": "core/src/rectangle.rs",
    "chars": 11721,
    "preview": "use crate::alignment;\nuse crate::{Padding, Point, Radians, Size, Vector};\n\n/// An axis-aligned rectangle.\n#[derive(Debug"
  },
  {
    "path": "core/src/renderer/null.rs",
    "chars": 6164,
    "preview": "use crate::alignment;\nuse crate::image::{self, Image};\nuse crate::renderer::{self, Renderer};\nuse crate::svg;\nuse crate:"
  },
  {
    "path": "core/src/renderer.rs",
    "chars": 5305,
    "preview": "//! Write your own renderer.\n#[cfg(debug_assertions)]\nmod null;\n\nuse crate::image;\nuse crate::{\n    Background, Border, "
  },
  {
    "path": "core/src/rotation.rs",
    "chars": 2199,
    "preview": "//! Control the rotation of some content (like an image) within a space.\nuse crate::{Degrees, Radians, Size};\n\n/// The s"
  },
  {
    "path": "core/src/settings.rs",
    "chars": 1893,
    "preview": "//! Configure your application.\nuse crate::renderer;\nuse crate::{Font, Pixels};\n\nuse std::borrow::Cow;\n\n/// The settings"
  },
  {
    "path": "core/src/shadow.rs",
    "chars": 295,
    "preview": "use crate::{Color, Vector};\n\n/// A shadow.\n#[derive(Debug, Clone, Copy, PartialEq, Default)]\npub struct Shadow {\n    ///"
  },
  {
    "path": "core/src/shell.rs",
    "chars": 6394,
    "preview": "use crate::clipboard;\nuse crate::event;\nuse crate::window;\nuse crate::{Clipboard, InputMethod};\n\n/// A connection to the"
  },
  {
    "path": "core/src/size.rs",
    "chars": 4635,
    "preview": "use crate::{Length, Radians, Vector};\n\n/// An amount of space in 2 dimensions.\n#[derive(Debug, Clone, Copy, PartialEq, E"
  },
  {
    "path": "core/src/svg.rs",
    "chars": 4183,
    "preview": "//! Load and draw vector graphics.\nuse crate::{Color, Radians, Rectangle, Size};\n\nuse rustc_hash::FxHasher;\nuse std::bor"
  },
  {
    "path": "core/src/text/editor.rs",
    "chars": 6712,
    "preview": "//! Edit text.\nuse crate::text::highlighter::{self, Highlighter};\nuse crate::text::{LineHeight, Wrapping};\nuse crate::{P"
  },
  {
    "path": "core/src/text/highlighter.rs",
    "chars": 2387,
    "preview": "//! Highlight text.\nuse crate::Color;\n\nuse std::ops::Range;\n\n/// A type capable of highlighting text.\n///\n/// A [`Highli"
  },
  {
    "path": "core/src/text/paragraph.rs",
    "chars": 5820,
    "preview": "//! Draw paragraphs.\nuse crate::alignment;\nuse crate::text::{\n    Alignment, Difference, Ellipsis, Hit, LineHeight, Shap"
  },
  {
    "path": "core/src/text.rs",
    "chars": 19454,
    "preview": "//! Draw and interact with text.\npub mod editor;\npub mod highlighter;\npub mod paragraph;\n\npub use editor::Editor;\npub us"
  },
  {
    "path": "core/src/theme/palette.rs",
    "chars": 22898,
    "preview": "//! Define the colors of a theme.\nuse crate::{Color, color};\n\nuse std::sync::LazyLock;\n\n/// An extended set of colors ge"
  },
  {
    "path": "core/src/theme.rs",
    "chars": 10723,
    "preview": "//! Use the built-in theme and styles.\npub mod palette;\n\npub use palette::Palette;\n\nuse crate::Color;\n\nuse std::borrow::"
  },
  {
    "path": "core/src/time.rs",
    "chars": 863,
    "preview": "//! Keep track of time, both in native and web platforms!\n\npub use web_time::Duration;\npub use web_time::Instant;\npub us"
  },
  {
    "path": "core/src/touch.rs",
    "chars": 673,
    "preview": "//! Build touch events.\nuse crate::Point;\n\n/// A touch interaction.\n#[derive(Debug, Clone, Copy, PartialEq)]\n#[allow(mis"
  },
  {
    "path": "core/src/transformation.rs",
    "chars": 3086,
    "preview": "use crate::{Point, Rectangle, Size, Vector};\n\nuse glam::{Mat4, Vec3, Vec4};\nuse std::ops::Mul;\n\n/// A 2D transformation "
  },
  {
    "path": "core/src/vector.rs",
    "chars": 2572,
    "preview": "/// A 2D vector.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub struct Vector<T = f32> {\n    /// The X compon"
  },
  {
    "path": "core/src/widget/id.rs",
    "chars": 1213,
    "preview": "use std::borrow;\nuse std::sync::atomic::{self, AtomicUsize};\n\nstatic NEXT_ID: AtomicUsize = AtomicUsize::new(0);\n\n/// Th"
  },
  {
    "path": "core/src/widget/operation/focusable.rs",
    "chars": 6780,
    "preview": "//! Operate on widgets that can be focused.\nuse crate::Rectangle;\nuse crate::widget::Id;\nuse crate::widget::operation::{"
  },
  {
    "path": "core/src/widget/operation/scrollable.rs",
    "chars": 4531,
    "preview": "//! Operate on widgets that can be scrolled.\nuse crate::widget::{Id, Operation};\nuse crate::{Rectangle, Vector};\n\n/// Th"
  },
  {
    "path": "core/src/widget/operation/text_input.rs",
    "chars": 4584,
    "preview": "//! Operate on widgets that have text input.\nuse crate::Rectangle;\nuse crate::widget::Id;\nuse crate::widget::operation::"
  },
  {
    "path": "core/src/widget/operation.rs",
    "chars": 13707,
    "preview": "//! Query or update internal widget state.\npub mod focusable;\npub mod scrollable;\npub mod text_input;\n\npub use focusable"
  },
  {
    "path": "core/src/widget/text.rs",
    "chars": 12775,
    "preview": "//! Text widgets display information through writing.\n//!\n//! # Example\n//! ```no_run\n//! # mod iced { pub mod widget { "
  },
  {
    "path": "core/src/widget/tree.rs",
    "chars": 7570,
    "preview": "//! Store internal widget state in a state tree to ensure continuity.\nuse crate::Widget;\n\nuse std::any::{self, Any};\nuse"
  },
  {
    "path": "core/src/widget.rs",
    "chars": 4087,
    "preview": "//! Create custom widgets and operate on them.\npub mod operation;\npub mod text;\npub mod tree;\n\nmod id;\n\npub use id::Id;\n"
  },
  {
    "path": "core/src/window/direction.rs",
    "chars": 620,
    "preview": "/// The cardinal directions relative to the center of a window.\n#[derive(Debug, Clone, Copy)]\npub enum Direction {\n    /"
  },
  {
    "path": "core/src/window/event.rs",
    "chars": 2129,
    "preview": "use crate::time::Instant;\nuse crate::{Point, Size};\n\nuse std::path::PathBuf;\n\n/// A window-related event.\n#[derive(Parti"
  },
  {
    "path": "core/src/window/icon.rs",
    "chars": 2528,
    "preview": "//! Change the icon of a window.\nuse crate::Size;\n\nuse std::mem;\n\n/// Builds an  [`Icon`] from its RGBA pixels in the `s"
  },
  {
    "path": "core/src/window/id.rs",
    "chars": 585,
    "preview": "use std::fmt;\nuse std::hash::Hash;\nuse std::sync::atomic::{self, AtomicU64};\n\n/// The id of the window.\n#[derive(Debug, "
  },
  {
    "path": "core/src/window/level.rs",
    "chars": 596,
    "preview": "/// A window level groups windows with respect to their z-position.\n///\n/// The relative ordering between windows in dif"
  },
  {
    "path": "core/src/window/mode.rs",
    "chars": 307,
    "preview": "/// The mode of a window-based application.\n#[derive(Debug, Clone, Copy, PartialEq, Eq)]\npub enum Mode {\n    /// The app"
  },
  {
    "path": "core/src/window/position.rs",
    "chars": 1017,
    "preview": "use crate::{Point, Size};\n\n/// The position of a window in a given screen.\n#[derive(Debug, Clone, Copy, Default)]\npub en"
  },
  {
    "path": "core/src/window/redraw_request.rs",
    "chars": 1559,
    "preview": "use crate::time::Instant;\n\n/// A request to redraw a window.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord"
  },
  {
    "path": "core/src/window/screenshot.rs",
    "chars": 3129,
    "preview": "//! Take screenshots of a window.\nuse crate::{Bytes, Rectangle, Size};\n\nuse std::fmt::{Debug, Formatter};\n\n/// Data of a"
  },
  {
    "path": "core/src/window/settings/linux.rs",
    "chars": 682,
    "preview": "//! Platform specific settings for Linux.\n\n/// The platform specific window settings of an application.\n#[derive(Debug, "
  },
  {
    "path": "core/src/window/settings/macos.rs",
    "chars": 467,
    "preview": "//! Platform specific settings for macOS.\n\n/// The platform specific window settings of an application.\n#[derive(Debug, "
  },
  {
    "path": "core/src/window/settings/other.rs",
    "chars": 144,
    "preview": "/// The platform specific window settings of an application.\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]\npub s"
  },
  {
    "path": "core/src/window/settings/wasm.rs",
    "chars": 586,
    "preview": "//! Platform specific settings for WebAssembly.\n\n/// The platform specific window settings of an application.\n#[derive(D"
  },
  {
    "path": "core/src/window/settings/windows.rs",
    "chars": 1653,
    "preview": "//! Platform specific settings for Windows.\n\n/// The platform specific window settings of an application.\n#[derive(Debug"
  },
  {
    "path": "core/src/window/settings.rs",
    "chars": 3461,
    "preview": "//! Configure your windows.\n#[cfg(target_os = \"windows\")]\n#[path = \"settings/windows.rs\"]\npub mod platform;\n\n#[cfg(targe"
  },
  {
    "path": "core/src/window/user_attention.rs",
    "chars": 741,
    "preview": "/// The type of user attention to request.\n///\n/// ## Platform-specific\n///\n/// - **X11:** Sets the WM's `XUrgencyHint`."
  },
  {
    "path": "core/src/window.rs",
    "chars": 500,
    "preview": "//! Build window-based GUI applications.\npub mod icon;\npub mod screenshot;\npub mod settings;\n\nmod direction;\nmod event;\n"
  },
  {
    "path": "debug/Cargo.toml",
    "chars": 640,
    "preview": "[package]\nname = \"iced_debug\"\ndescription = \"A pluggable API for debugging iced applications\"\nversion.workspace = true\ne"
  },
  {
    "path": "debug/src/lib.rs",
    "chars": 11500,
    "preview": "pub use iced_core as core;\npub use iced_futures as futures;\n\nuse crate::core::theme::palette;\nuse crate::core::window;\nu"
  },
  {
    "path": "devtools/Cargo.toml",
    "chars": 575,
    "preview": "[package]\nname = \"iced_devtools\"\ndescription = \"Attachable developer tools for any iced program\"\nversion.workspace = tru"
  },
  {
    "path": "devtools/src/comet.rs",
    "chars": 3607,
    "preview": "use crate::runtime::task::{self, Task};\n\nuse std::process;\n\npub const COMPATIBLE_REVISION: &str = \"fbef808eed51562f0ea60"
  },
  {
    "path": "devtools/src/lib.rs",
    "chars": 16174,
    "preview": "#![allow(missing_docs)]\nuse iced_debug as debug;\nuse iced_program as program;\nuse iced_program::runtime;\nuse iced_progra"
  },
  {
    "path": "devtools/src/time_machine.rs",
    "chars": 1781,
    "preview": "use crate::Program;\n\n#[cfg(feature = \"time-travel\")]\npub struct TimeMachine<P>\nwhere\n    P: Program,\n{\n    state: Option"
  },
  {
    "path": "docs/redirect.html",
    "chars": 416,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n    <meta charset=\"UTF-8\">\n    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=ed"
  },
  {
    "path": "docs/release_summary.py",
    "chars": 1995,
    "preview": "import requests\nimport os\n\ndef get_merged_prs(repo, milestone, token):\n    url = f'https://api.github.com/repos/{repo}/p"
  },
  {
    "path": "examples/README.md",
    "chars": 5324,
    "preview": "# Examples\n__Iced moves fast and the `master` branch can contain breaking changes!__ If you want to browse examples that"
  },
  {
    "path": "examples/arc/Cargo.toml",
    "chars": 205,
    "preview": "[package]\nname = \"arc\"\nversion = \"0.1.0\"\nauthors = [\"ThatsNoMoon <git@thatsnomoon.dev>\"]\nedition = \"2024\"\npublish = fals"
  },
  {
    "path": "examples/arc/README.md",
    "chars": 297,
    "preview": "## Arc\n\nAn application that uses the `Canvas` widget to draw a rotating arc.\n\nThis is a simple demo for https://github.c"
  },
  {
    "path": "examples/arc/src/main.rs",
    "chars": 2427,
    "preview": "use std::{f32::consts::PI, time::Instant};\n\nuse iced::mouse;\nuse iced::widget::canvas::{self, Cache, Canvas, Geometry, P"
  },
  {
    "path": "examples/bezier_tool/Cargo.toml",
    "chars": 214,
    "preview": "[package]\nname = \"bezier_tool\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"20"
  },
  {
    "path": "examples/bezier_tool/README.md",
    "chars": 329,
    "preview": "## Bézier tool\n\nA Paint-like tool for drawing Bézier curves using the `Canvas` widget.\n\nThe __[`main`]__ file contains a"
  },
  {
    "path": "examples/bezier_tool/src/main.rs",
    "chars": 7064,
    "preview": "//! This example showcases an interactive `Canvas` for drawing Bézier curves.\nuse iced::widget::{button, container, hove"
  },
  {
    "path": "examples/changelog/Cargo.toml",
    "chars": 562,
    "preview": "[package]\nname = \"changelog\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024"
  },
  {
    "path": "examples/changelog/src/changelog.rs",
    "chars": 11908,
    "preview": "use jiff::Timestamp;\nuse serde::Deserialize;\nuse tokio::fs;\nuse tokio::process;\n\nuse std::collections::{BTreeMap, BTreeS"
  },
  {
    "path": "examples/changelog/src/icon.rs",
    "chars": 251,
    "preview": "use iced::widget::{text, Text};\nuse iced::Font;\n\npub const FONT_BYTES: &[u8] = include_bytes!(\"../fonts/changelog-icons."
  },
  {
    "path": "examples/changelog/src/main.rs",
    "chars": 12059,
    "preview": "mod changelog;\n\nuse crate::changelog::Changelog;\n\nuse iced::font;\nuse iced::widget::{\n    button, center, column, contai"
  },
  {
    "path": "examples/checkbox/Cargo.toml",
    "chars": 175,
    "preview": "[package]\nname = \"checkbox\"\nversion = \"0.1.0\"\nauthors = [\"Casper Rogild Storm<casper@rogildstorm.com>\"]\nedition = \"2024\""
  },
  {
    "path": "examples/checkbox/README.md",
    "chars": 195,
    "preview": "## Checkbox\n\nA box that can be checked.\n\nThe __[`main`]__ file contains all the code of the example.\n\nYou can run it wit"
  },
  {
    "path": "examples/checkbox/src/main.rs",
    "chars": 2160,
    "preview": "use iced::widget::{center, checkbox, column, row, text};\nuse iced::{Element, Font};\n\nconst ICON_FONT: Font = Font::new(\""
  },
  {
    "path": "examples/clock/Cargo.toml",
    "chars": 259,
    "preview": "[package]\nname = \"clock\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\"\npu"
  },
  {
    "path": "examples/clock/README.md",
    "chars": 408,
    "preview": "## Clock\n\nAn application that uses the `Canvas` widget to draw a clock and its hands to display the current time.\n\nThe _"
  },
  {
    "path": "examples/clock/src/main.rs",
    "chars": 6165,
    "preview": "use iced::alignment;\nuse iced::mouse;\nuse iced::time::{self, milliseconds};\nuse iced::widget::canvas::{Cache, Geometry, "
  },
  {
    "path": "examples/color_palette/Cargo.toml",
    "chars": 215,
    "preview": "[package]\nname = \"color_palette\"\nversion = \"0.1.0\"\nauthors = [\"Clark Moody <clark@clarkmoody.com>\"]\nedition = \"2024\"\npub"
  },
  {
    "path": "examples/color_palette/README.md",
    "chars": 216,
    "preview": "## Color palette\n\nA color palette generator, based on a user-defined root color.\n\n<div align=\"center\">\n  <img src=\"scree"
  },
  {
    "path": "examples/color_palette/src/main.rs",
    "chars": 13458,
    "preview": "use iced::alignment;\nuse iced::mouse;\nuse iced::theme;\nuse iced::widget::canvas::{self, Canvas, Frame, Geometry, Path};\n"
  },
  {
    "path": "examples/combo_box/Cargo.toml",
    "chars": 191,
    "preview": "[package]\nname = \"combo_box\"\nversion = \"0.1.0\"\nauthors = [\"Joao Freitas <jhff.15@gmail.com>\"]\nedition = \"2024\"\npublish ="
  },
  {
    "path": "examples/combo_box/README.md",
    "chars": 364,
    "preview": "## Combo-Box\n\nA dropdown list of searchable and selectable options.\n\nIt displays and positions an overlay based on the w"
  },
  {
    "path": "examples/combo_box/src/main.rs",
    "chars": 3573,
    "preview": "use iced::widget::{center, column, combo_box, scrollable, space, text};\nuse iced::{Center, Element, Fill};\n\npub fn main("
  },
  {
    "path": "examples/counter/Cargo.toml",
    "chars": 335,
    "preview": "[package]\nname = \"counter\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\"\n"
  },
  {
    "path": "examples/counter/README.md",
    "chars": 437,
    "preview": "## Counter\n\nThe classic counter example explained in the [`README`](../../README.md).\n\nThe __[`main`]__ file contains al"
  },
  {
    "path": "examples/counter/index.html",
    "chars": 365,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n    <meta charset=\"utf-8\" content=\"text/html; charset=utf-8\" />\n    <meta name=\""
  },
  {
    "path": "examples/counter/src/main.rs",
    "chars": 1464,
    "preview": "use iced::Center;\nuse iced::widget::{Column, button, column, text};\n\npub fn main() -> iced::Result {\n    iced::run(Count"
  },
  {
    "path": "examples/custom_quad/Cargo.toml",
    "chars": 176,
    "preview": "[package]\nname = \"custom_quad\"\nversion = \"0.1.0\"\nauthors = [\"Robert Krahn\"]\nedition = \"2024\"\npublish = false\n\n[dependenc"
  },
  {
    "path": "examples/custom_quad/src/main.rs",
    "chars": 6251,
    "preview": "//! This example showcases a drawing a quad.\nuse iced::border;\nuse iced::widget::{center, column, slider, text, toggler}"
  },
  {
    "path": "examples/custom_shader/Cargo.toml",
    "chars": 318,
    "preview": "[package]\nname = \"custom_shader\"\nversion = \"0.1.0\"\nauthors = [\"Bingus <shankern@protonmail.com>\"]\nedition = \"2024\"\n\n[dep"
  },
  {
    "path": "examples/custom_shader/src/main.rs",
    "chars": 3918,
    "preview": "mod scene;\n\nuse scene::Scene;\n\nuse iced::time::Instant;\nuse iced::wgpu;\nuse iced::widget::{center, checkbox, column, row"
  },
  {
    "path": "examples/custom_shader/src/scene/camera.rs",
    "chars": 1111,
    "preview": "use glam::{mat4, vec3, vec4};\nuse iced::Rectangle;\n\n#[derive(Copy, Clone)]\npub struct Camera {\n    eye: glam::Vec3,\n    "
  },
  {
    "path": "examples/custom_shader/src/scene/pipeline/buffer.rs",
    "chars": 1000,
    "preview": "use crate::wgpu;\n\n// A custom buffer container for dynamic resizing.\npub struct Buffer {\n    pub raw: wgpu::Buffer,\n    "
  },
  {
    "path": "examples/custom_shader/src/scene/pipeline/cube.rs",
    "chars": 10163,
    "preview": "use crate::scene::pipeline::Vertex;\nuse crate::wgpu;\n\nuse glam::{Vec3, vec2, vec3};\nuse rand::{Rng, thread_rng};\n\n/// A "
  },
  {
    "path": "examples/custom_shader/src/scene/pipeline/uniforms.rs",
    "chars": 579,
    "preview": "use crate::scene::Camera;\n\nuse iced::{Color, Rectangle};\n\n#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable"
  },
  {
    "path": "examples/custom_shader/src/scene/pipeline/vertex.rs",
    "chars": 762,
    "preview": "use crate::wgpu;\n\n#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]\n#[repr(C)]\npub struct Vertex {\n    pu"
  },
  {
    "path": "examples/custom_shader/src/scene/pipeline.rs",
    "chars": 21919,
    "preview": "pub mod cube;\n\nmod buffer;\nmod uniforms;\nmod vertex;\n\npub use uniforms::Uniforms;\n\nuse buffer::Buffer;\nuse vertex::Verte"
  },
  {
    "path": "examples/custom_shader/src/scene.rs",
    "chars": 4268,
    "preview": "mod camera;\nmod pipeline;\n\nuse camera::Camera;\nuse pipeline::Pipeline;\n\nuse crate::wgpu;\nuse pipeline::cube::{self, Cube"
  },
  {
    "path": "examples/custom_shader/src/shaders/cubes.wgsl",
    "chars": 4110,
    "preview": "struct Uniforms {\n    projection: mat4x4<f32>,\n    camera_pos: vec4<f32>,\n    light_color: vec4<f32>,\n}\n\nconst LIGHT_POS"
  },
  {
    "path": "examples/custom_shader/src/shaders/depth.wgsl",
    "chars": 1092,
    "preview": "var<private> positions: array<vec2<f32>, 6> = array<vec2<f32>, 6>(\n    vec2<f32>(-1.0, 1.0),\n    vec2<f32>(-1.0, -1.0),\n"
  },
  {
    "path": "examples/custom_widget/Cargo.toml",
    "chars": 209,
    "preview": "[package]\nname = \"custom_widget\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \""
  },
  {
    "path": "examples/custom_widget/README.md",
    "chars": 333,
    "preview": "## Custom widget\n\nA demonstration of how to build a custom widget that draws a circle.\n\nThe __[`main`]__ file contains a"
  },
  {
    "path": "examples/custom_widget/src/main.rs",
    "chars": 2962,
    "preview": "//! This example showcases a simple native custom widget that draws a circle.\nmod circle {\n    use iced::advanced::layou"
  },
  {
    "path": "examples/delineate/Cargo.toml",
    "chars": 214,
    "preview": "[package]\nname = \"delineate\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024"
  },
  {
    "path": "examples/delineate/src/main.rs",
    "chars": 4937,
    "preview": "use iced::event::{self, Event};\nuse iced::mouse;\nuse iced::widget::{self, column, container, row, scrollable, selector, "
  },
  {
    "path": "examples/download_progress/Cargo.toml",
    "chars": 305,
    "preview": "[package]\nname = \"download_progress\"\nversion = \"0.1.0\"\nauthors = [\"Songtronix <contact@songtronix.com>\", \"Folyd <lyshuho"
  },
  {
    "path": "examples/download_progress/README.md",
    "chars": 503,
    "preview": "## Download progress\n\nA basic application that asynchronously downloads multiple dummy files of 100 MB and tracks the do"
  },
  {
    "path": "examples/download_progress/index.html",
    "chars": 438,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\" style=\"height: 100%\">\n<head>\n    <meta charset=\"utf-8\" content=\"text/html; charset=utf-8"
  },
  {
    "path": "examples/download_progress/src/download.rs",
    "chars": 1155,
    "preview": "use iced::futures::StreamExt;\nuse iced::task::{Straw, sipper};\n\nuse std::sync::Arc;\n\npub fn download(url: impl AsRef<str"
  },
  {
    "path": "examples/download_progress/src/main.rs",
    "chars": 5053,
    "preview": "mod download;\n\nuse download::download;\n\nuse iced::task;\nuse iced::widget::{Column, button, center, column, progress_bar,"
  },
  {
    "path": "examples/editor/Cargo.toml",
    "chars": 289,
    "preview": "[package]\nname = \"editor\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector@hecrj.dev>\"]\nedition = \"2024\"\npubli"
  },
  {
    "path": "examples/editor/src/main.rs",
    "chars": 9317,
    "preview": "use iced::highlighter;\nuse iced::keyboard;\nuse iced::widget::{\n    button, center_x, column, container, operation, pick_"
  },
  {
    "path": "examples/events/Cargo.toml",
    "chars": 199,
    "preview": "[package]\nname = \"events\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\"\np"
  },
  {
    "path": "examples/events/README.md",
    "chars": 233,
    "preview": "## Events\n\nA log of native events displayed using a conditional `Subscription`.\n\nThe __[`main`]__ file contains all the "
  },
  {
    "path": "examples/events/src/main.rs",
    "chars": 2248,
    "preview": "use iced::event::{self, Event};\nuse iced::widget::{Column, button, center, checkbox, text};\nuse iced::window;\nuse iced::"
  },
  {
    "path": "examples/exit/Cargo.toml",
    "chars": 113,
    "preview": "[package]\nname = \"exit\"\nversion = \"0.1.0\"\nedition = \"2024\"\npublish = false\n\n[dependencies]\niced.workspace = true\n"
  },
  {
    "path": "examples/exit/README.md",
    "chars": 208,
    "preview": "## Exit\n\nHow to exit an application based on user input.\n\nThe __[`main`]__ file contains all the code of the example.\n\nY"
  },
  {
    "path": "examples/exit/src/main.rs",
    "chars": 1192,
    "preview": "use iced::widget::{button, center, column};\nuse iced::window;\nuse iced::{Center, Element, Task};\n\npub fn main() -> iced:"
  },
  {
    "path": "examples/ferris/Cargo.toml",
    "chars": 217,
    "preview": "[package]\nname = \"ferris\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\"\np"
  },
  {
    "path": "examples/ferris/src/main.rs",
    "chars": 6211,
    "preview": "use iced::time::Instant;\nuse iced::widget::{center, checkbox, column, container, image, pick_list, row, slider, text};\nu"
  },
  {
    "path": "examples/gallery/Cargo.toml",
    "chars": 473,
    "preview": "[package]\nname = \"gallery\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\"\n"
  },
  {
    "path": "examples/gallery/src/civitai.rs",
    "chars": 4692,
    "preview": "use serde::Deserialize;\nuse sipper::{Straw, sipper};\nuse tokio::task;\n\nuse std::fmt;\nuse std::io;\nuse std::sync::{Arc, L"
  },
  {
    "path": "examples/gallery/src/main.rs",
    "chars": 17081,
    "preview": "//! A simple gallery that displays the daily featured images of Civitai.\n//!\n//! Showcases lazy loading of images in the"
  },
  {
    "path": "examples/game_of_life/Cargo.toml",
    "chars": 349,
    "preview": "[package]\nname = \"game_of_life\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2"
  },
  {
    "path": "examples/game_of_life/README.md",
    "chars": 650,
    "preview": "## Game of Life\n\nAn interactive version of the [Game of Life], invented by [John Horton Conway].\n\nIt runs a simulation i"
  },
  {
    "path": "examples/game_of_life/src/main.rs",
    "chars": 27451,
    "preview": "//! This example showcases an interactive version of the Game of Life, invented\n//! by John Conway. It leverages a `Canv"
  },
  {
    "path": "examples/game_of_life/src/preset.rs",
    "chars": 3794,
    "preview": "#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]\npub enum Preset {\n    Custom,\n    #[default]\n    Xkcd,\n    Glider,"
  },
  {
    "path": "examples/geometry/Cargo.toml",
    "chars": 204,
    "preview": "[package]\nname = \"geometry\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"2024\""
  },
  {
    "path": "examples/geometry/README.md",
    "chars": 355,
    "preview": "## Geometry\n\nA custom widget showcasing how to draw geometry with the `Mesh2D` primitive in [`iced_wgpu`](../../wgpu).\n\n"
  },
  {
    "path": "examples/geometry/src/main.rs",
    "chars": 6508,
    "preview": "//! This example showcases a simple native custom widget that renders using\n//! arbitrary low-level geometry.\nmod rainbo"
  },
  {
    "path": "examples/gradient/Cargo.toml",
    "chars": 171,
    "preview": "[package]\nname = \"gradient\"\nversion = \"0.1.0\"\nedition = \"2024\"\npublish = false\n\n[dependencies]\niced.workspace = true\nice"
  },
  {
    "path": "examples/gradient/src/main.rs",
    "chars": 3393,
    "preview": "use iced::gradient;\nuse iced::theme;\nuse iced::widget::{checkbox, column, container, row, slider, space, text};\nuse iced"
  },
  {
    "path": "examples/integration/.gitignore",
    "chars": 12,
    "preview": "*.wasm\n*.js\n"
  },
  {
    "path": "examples/integration/Cargo.toml",
    "chars": 737,
    "preview": "[package]\nname = \"integration\"\nversion = \"0.1.0\"\nauthors = [\"Héctor Ramón Jiménez <hector0193@gmail.com>\"]\nedition = \"20"
  },
  {
    "path": "examples/integration/README.md",
    "chars": 384,
    "preview": "## `wgpu` integration\n\nA demonstration of how to integrate Iced in an existing [`wgpu`] application.\n\nThe __[`main`]__ f"
  },
  {
    "path": "examples/integration/src/controls.rs",
    "chars": 2193,
    "preview": "use iced_wgpu::Renderer;\nuse iced_widget::{bottom, column, row, slider, text, text_input};\nuse iced_winit::core::{Color,"
  },
  {
    "path": "examples/integration/src/main.rs",
    "chars": 13529,
    "preview": "mod controls;\nmod scene;\n\nuse controls::Controls;\nuse scene::Scene;\n\nuse iced_wgpu::graphics::{Shell, Viewport};\nuse ice"
  }
]

// ... and 342 more files (download for full content)