Full Code of emilk/egui for AI

gitextract_i4it_2fc/

├── .cargo/
│   └── config.toml
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── feature_request.md
│   │   └── other.md
│   ├── pull_request_template.md
│   └── workflows/
│       ├── cargo_machete.yml
│       ├── deploy_web_demo.yml
│       ├── enforce_branch_name.yml
│       ├── labels.yml
│       ├── link_checker.yml
│       ├── png_only_on_lfs.yml
│       ├── preview_build.yml
│       ├── preview_cleanup.yml
│       ├── preview_comment.yml
│       ├── preview_deploy.yml
│       ├── rust.yml
│       ├── typos.yml
│       └── update_kittest_snapshots.yml
├── .gitignore
├── .typos.toml
├── ARCHITECTURE.md
├── CHANGELOG.md
├── CODEOWNERS
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── RELEASES.md
├── clippy.toml
├── crates/
│   ├── ecolor/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── cint_impl.rs
│   │       ├── color32.rs
│   │       ├── hex_color_macro.rs
│   │       ├── hex_color_runtime.rs
│   │       ├── hsva.rs
│   │       ├── hsva_gamma.rs
│   │       ├── lib.rs
│   │       └── rgba.rs
│   ├── eframe/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── epi.rs
│   │       ├── icon_data.rs
│   │       ├── lib.rs
│   │       ├── native/
│   │       │   ├── app_icon.rs
│   │       │   ├── epi_integration.rs
│   │       │   ├── event_loop_context.rs
│   │       │   ├── file_storage.rs
│   │       │   ├── glow_integration.rs
│   │       │   ├── mod.rs
│   │       │   ├── run.rs
│   │       │   ├── wgpu_integration.rs
│   │       │   └── winit_integration.rs
│   │       ├── stopwatch.rs
│   │       └── web/
│   │           ├── app_runner.rs
│   │           ├── backend.rs
│   │           ├── events.rs
│   │           ├── input.rs
│   │           ├── mod.rs
│   │           ├── panic_handler.rs
│   │           ├── screen_reader.rs
│   │           ├── storage.rs
│   │           ├── text_agent.rs
│   │           ├── web_logger.rs
│   │           ├── web_painter.rs
│   │           ├── web_painter_glow.rs
│   │           ├── web_painter_wgpu.rs
│   │           └── web_runner.rs
│   ├── egui/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── examples/
│   │   │   └── README.md
│   │   └── src/
│   │       ├── animation_manager.rs
│   │       ├── atomics/
│   │       │   ├── atom.rs
│   │       │   ├── atom_ext.rs
│   │       │   ├── atom_kind.rs
│   │       │   ├── atom_layout.rs
│   │       │   ├── atoms.rs
│   │       │   ├── mod.rs
│   │       │   ├── sized_atom.rs
│   │       │   └── sized_atom_kind.rs
│   │       ├── cache/
│   │       │   ├── cache_storage.rs
│   │       │   ├── cache_trait.rs
│   │       │   ├── frame_cache.rs
│   │       │   ├── frame_publisher.rs
│   │       │   └── mod.rs
│   │       ├── callstack.rs
│   │       ├── containers/
│   │       │   ├── area.rs
│   │       │   ├── close_tag.rs
│   │       │   ├── collapsing_header.rs
│   │       │   ├── combo_box.rs
│   │       │   ├── frame.rs
│   │       │   ├── menu.rs
│   │       │   ├── mod.rs
│   │       │   ├── modal.rs
│   │       │   ├── old_popup.rs
│   │       │   ├── panel.rs
│   │       │   ├── popup.rs
│   │       │   ├── resize.rs
│   │       │   ├── scene.rs
│   │       │   ├── scroll_area.rs
│   │       │   ├── sides.rs
│   │       │   ├── tooltip.rs
│   │       │   └── window.rs
│   │       ├── context.rs
│   │       ├── data/
│   │       │   ├── input.rs
│   │       │   ├── key.rs
│   │       │   ├── mod.rs
│   │       │   ├── output.rs
│   │       │   └── user_data.rs
│   │       ├── debug_text.rs
│   │       ├── drag_and_drop.rs
│   │       ├── grid.rs
│   │       ├── gui_zoom.rs
│   │       ├── hit_test.rs
│   │       ├── id.rs
│   │       ├── input_state/
│   │       │   ├── mod.rs
│   │       │   ├── touch_state.rs
│   │       │   └── wheel_state.rs
│   │       ├── interaction.rs
│   │       ├── introspection.rs
│   │       ├── layers.rs
│   │       ├── layout.rs
│   │       ├── lib.rs
│   │       ├── load/
│   │       │   ├── bytes_loader.rs
│   │       │   └── texture_loader.rs
│   │       ├── load.rs
│   │       ├── memory/
│   │       │   ├── mod.rs
│   │       │   └── theme.rs
│   │       ├── menu.rs
│   │       ├── os.rs
│   │       ├── painter.rs
│   │       ├── pass_state.rs
│   │       ├── placer.rs
│   │       ├── plugin.rs
│   │       ├── response.rs
│   │       ├── sense.rs
│   │       ├── style.rs
│   │       ├── text_selection/
│   │       │   ├── accesskit_text.rs
│   │       │   ├── cursor_range.rs
│   │       │   ├── label_text_selection.rs
│   │       │   ├── mod.rs
│   │       │   ├── text_cursor_state.rs
│   │       │   └── visuals.rs
│   │       ├── ui.rs
│   │       ├── ui_builder.rs
│   │       ├── ui_stack.rs
│   │       ├── util/
│   │       │   ├── fixed_cache.rs
│   │       │   ├── id_type_map.rs
│   │       │   ├── mod.rs
│   │       │   └── undoer.rs
│   │       ├── viewport.rs
│   │       ├── widget_rect.rs
│   │       ├── widget_style.rs
│   │       ├── widget_text.rs
│   │       └── widgets/
│   │           ├── button.rs
│   │           ├── checkbox.rs
│   │           ├── color_picker.rs
│   │           ├── drag_value.rs
│   │           ├── hyperlink.rs
│   │           ├── image.rs
│   │           ├── image_button.rs
│   │           ├── label.rs
│   │           ├── mod.rs
│   │           ├── progress_bar.rs
│   │           ├── radio_button.rs
│   │           ├── selected_label.rs
│   │           ├── separator.rs
│   │           ├── slider.rs
│   │           ├── spinner.rs
│   │           └── text_edit/
│   │               ├── builder.rs
│   │               ├── mod.rs
│   │               ├── output.rs
│   │               ├── state.rs
│   │               └── text_buffer.rs
│   ├── egui-wgpu/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── capture.rs
│   │       ├── egui.wgsl
│   │       ├── lib.rs
│   │       ├── renderer.rs
│   │       ├── setup.rs
│   │       ├── texture_copy.wgsl
│   │       └── winit.rs
│   ├── egui-winit/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── clipboard.rs
│   │       ├── lib.rs
│   │       ├── safe_area.rs
│   │       └── window_settings.rs
│   ├── egui_demo_app/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── src/
│   │   │   ├── accessibility_inspector.rs
│   │   │   ├── apps/
│   │   │   │   ├── custom3d_glow.rs
│   │   │   │   ├── custom3d_wgpu.rs
│   │   │   │   ├── custom3d_wgpu_shader.wgsl
│   │   │   │   ├── fractal_clock.rs
│   │   │   │   ├── http_app.rs
│   │   │   │   ├── image_viewer.rs
│   │   │   │   └── mod.rs
│   │   │   ├── backend_panel.rs
│   │   │   ├── frame_history.rs
│   │   │   ├── lib.rs
│   │   │   ├── main.rs
│   │   │   ├── web.rs
│   │   │   └── wrap_app.rs
│   │   └── tests/
│   │       └── test_demo_app.rs
│   ├── egui_demo_lib/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── benches/
│   │   │   └── benchmark.rs
│   │   ├── src/
│   │   │   ├── demo/
│   │   │   │   ├── about.rs
│   │   │   │   ├── code_editor.rs
│   │   │   │   ├── code_example.rs
│   │   │   │   ├── dancing_strings.rs
│   │   │   │   ├── demo_app_windows.rs
│   │   │   │   ├── drag_and_drop.rs
│   │   │   │   ├── extra_viewport.rs
│   │   │   │   ├── font_book.rs
│   │   │   │   ├── frame_demo.rs
│   │   │   │   ├── highlighting.rs
│   │   │   │   ├── interactive_container.rs
│   │   │   │   ├── misc_demo_window.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── modals.rs
│   │   │   │   ├── multi_touch.rs
│   │   │   │   ├── paint_bezier.rs
│   │   │   │   ├── painting.rs
│   │   │   │   ├── panels.rs
│   │   │   │   ├── password.rs
│   │   │   │   ├── popups.rs
│   │   │   │   ├── scene.rs
│   │   │   │   ├── screenshot.rs
│   │   │   │   ├── scrolling.rs
│   │   │   │   ├── sliders.rs
│   │   │   │   ├── strip_demo.rs
│   │   │   │   ├── table_demo.rs
│   │   │   │   ├── tests/
│   │   │   │   │   ├── clipboard_test.rs
│   │   │   │   │   ├── cursor_test.rs
│   │   │   │   │   ├── grid_test.rs
│   │   │   │   │   ├── id_test.rs
│   │   │   │   │   ├── input_event_history.rs
│   │   │   │   │   ├── input_test.rs
│   │   │   │   │   ├── layout_test.rs
│   │   │   │   │   ├── manual_layout_test.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   ├── svg_test.rs
│   │   │   │   │   ├── tessellation_test.rs
│   │   │   │   │   └── window_resize_test.rs
│   │   │   │   ├── text_edit.rs
│   │   │   │   ├── text_layout.rs
│   │   │   │   ├── toggle_switch.rs
│   │   │   │   ├── tooltips.rs
│   │   │   │   ├── undo_redo.rs
│   │   │   │   ├── widget_gallery.rs
│   │   │   │   └── window_options.rs
│   │   │   ├── easy_mark/
│   │   │   │   ├── easy_mark_editor.rs
│   │   │   │   ├── easy_mark_highlighter.rs
│   │   │   │   ├── easy_mark_parser.rs
│   │   │   │   ├── easy_mark_viewer.rs
│   │   │   │   └── mod.rs
│   │   │   ├── lib.rs
│   │   │   └── rendering_test.rs
│   │   └── tests/
│   │       ├── image_blending.rs
│   │       └── misc.rs
│   ├── egui_extras/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── datepicker/
│   │       │   ├── button.rs
│   │       │   ├── mod.rs
│   │       │   └── popup.rs
│   │       ├── image.rs
│   │       ├── layout.rs
│   │       ├── lib.rs
│   │       ├── loaders/
│   │       │   ├── file_loader.rs
│   │       │   ├── gif_loader.rs
│   │       │   ├── http_loader.rs
│   │       │   ├── image_loader.rs
│   │       │   ├── svg_loader.rs
│   │       │   └── webp_loader.rs
│   │       ├── loaders.rs
│   │       ├── sizing.rs
│   │       ├── strip.rs
│   │       ├── syntax_highlighting.rs
│   │       └── table.rs
│   ├── egui_glow/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── examples/
│   │   │   └── pure_glow.rs
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── misc_util.rs
│   │       ├── painter.rs
│   │       ├── shader/
│   │       │   ├── fragment.glsl
│   │       │   └── vertex.glsl
│   │       ├── shader_version.rs
│   │       ├── vao.rs
│   │       └── winit.rs
│   ├── egui_kittest/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── src/
│   │   │   ├── app_kind.rs
│   │   │   ├── builder.rs
│   │   │   ├── config.rs
│   │   │   ├── lib.rs
│   │   │   ├── node.rs
│   │   │   ├── renderer.rs
│   │   │   ├── snapshot.rs
│   │   │   ├── texture_to_image.rs
│   │   │   └── wgpu.rs
│   │   └── tests/
│   │       ├── accesskit.rs
│   │       ├── menu.rs
│   │       ├── popup.rs
│   │       ├── regression_tests.rs
│   │       └── tests.rs
│   ├── egui_plot/
│   │   └── README.md
│   ├── egui_web/
│   │   ├── CHANGELOG.md
│   │   └── README.md
│   ├── emath/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── align.rs
│   │       ├── easing.rs
│   │       ├── gui_rounding.rs
│   │       ├── history.rs
│   │       ├── lib.rs
│   │       ├── numeric.rs
│   │       ├── ordered_float.rs
│   │       ├── pos2.rs
│   │       ├── range.rs
│   │       ├── rect.rs
│   │       ├── rect_align.rs
│   │       ├── rect_transform.rs
│   │       ├── rot2.rs
│   │       ├── smart_aim.rs
│   │       ├── ts_transform.rs
│   │       ├── vec2.rs
│   │       └── vec2b.rs
│   ├── epaint/
│   │   ├── CHANGELOG.md
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── benches/
│   │   │   └── benchmark.rs
│   │   └── src/
│   │       ├── brush.rs
│   │       ├── color.rs
│   │       ├── corner_radius.rs
│   │       ├── corner_radius_f32.rs
│   │       ├── image.rs
│   │       ├── lib.rs
│   │       ├── margin.rs
│   │       ├── margin_f32.rs
│   │       ├── mesh.rs
│   │       ├── mutex.rs
│   │       ├── shadow.rs
│   │       ├── shape_transform.rs
│   │       ├── shapes/
│   │       │   ├── bezier_shape.rs
│   │       │   ├── circle_shape.rs
│   │       │   ├── ellipse_shape.rs
│   │       │   ├── mod.rs
│   │       │   ├── paint_callback.rs
│   │       │   ├── path_shape.rs
│   │       │   ├── rect_shape.rs
│   │       │   ├── shape.rs
│   │       │   └── text_shape.rs
│   │       ├── stats.rs
│   │       ├── stroke.rs
│   │       ├── tessellator.rs
│   │       ├── text/
│   │       │   ├── cursor.rs
│   │       │   ├── font.rs
│   │       │   ├── fonts.rs
│   │       │   ├── mod.rs
│   │       │   ├── text_layout.rs
│   │       │   └── text_layout_types.rs
│   │       ├── texture_atlas.rs
│   │       ├── texture_handle.rs
│   │       ├── textures.rs
│   │       ├── util/
│   │       │   └── mod.rs
│   │       └── viewport.rs
│   └── epaint_default_fonts/
│       ├── CHANGELOG.md
│       ├── Cargo.toml
│       ├── README.md
│       ├── fonts/
│       │   ├── Hack-Regular.txt
│       │   ├── OFL.txt
│       │   ├── UFL.txt
│       │   ├── emoji-icon-font-mit-license.txt
│       │   └── list_fonts.py
│       └── src/
│           └── lib.rs
├── deny.toml
├── examples/
│   ├── README.md
│   ├── confirm_exit/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── custom_3d_glow/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── custom_font/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── custom_font_style/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── custom_keypad/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── keypad.rs
│   │       └── main.rs
│   ├── custom_style/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── custom_window_frame/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── external_eventloop/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── external_eventloop_async/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── app.rs
│   │       └── main.rs
│   ├── file_dialog/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── hello_android/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── lib.rs
│   │       └── main.rs
│   ├── hello_world/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── hello_world_par/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── hello_world_simple/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── images/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── keyboard_events/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── multiple_viewports/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── popups/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── puffin_profiler/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── run_all.sh
│   ├── screenshot/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── serial_windows/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   └── user_attention/
│       ├── Cargo.toml
│       ├── README.md
│       └── src/
│           └── main.rs
├── kittest.toml
├── lychee.toml
├── rust-toolchain
├── scripts/
│   ├── accept_snapshots.sh
│   ├── build_demo_web.sh
│   ├── cargo_deny.sh
│   ├── check.sh
│   ├── clippy_wasm/
│   │   └── clippy.toml
│   ├── clippy_wasm.sh
│   ├── docs.sh
│   ├── find_bloat.sh
│   ├── generate_changelog.py
│   ├── generate_example_screenshots.sh
│   ├── lint.py
│   ├── publish_crates.sh
│   ├── setup_web.sh
│   ├── start_server.sh
│   ├── update_snapshots_from_ci.sh
│   ├── wasm_bindgen_check.sh
│   └── wasm_size.sh
├── taplo.toml
├── tests/
│   ├── README.md
│   ├── egui_tests/
│   │   ├── Cargo.toml
│   │   └── tests/
│   │       ├── regression_tests.rs
│   │       ├── test_atoms.rs
│   │       ├── test_sides.rs
│   │       └── test_widgets.rs
│   ├── test_background_logic/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── test_egui_extras_compilation/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       └── main.rs
│   ├── test_inline_glow_paint/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── test_size_pass/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   ├── test_ui_stack/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   └── test_viewports/
│       ├── Cargo.toml
│       ├── README.md
│       └── src/
│           └── main.rs
├── web_demo/
│   ├── .gitignore
│   ├── CNAME
│   ├── README.md
│   ├── example.html
│   ├── index.html
│   └── multiple_apps.html
└── xtask/
    ├── Cargo.toml
    ├── README.md
    └── src/
        ├── deny.rs
        ├── main.rs
        └── utils.rs

SYMBOL INDEX (6186 symbols across 335 files)

FILE: crates/ecolor/src/cint_impl.rs
  method from (line 7) | fn from(srgba: Alpha<EncodedSrgb<u8>>) -> Self {
  method from (line 20) | fn from(srgba: PremultipliedAlpha<EncodedSrgb<u8>>) -> Self {
  function from (line 31) | fn from(col: Color32) -> Self {
  method from (line 42) | fn from(srgba: PremultipliedAlpha<EncodedSrgb<f32>>) -> Self {
  function from (line 59) | fn from(col: Color32) -> Self {
  type CintTy (line 76) | type CintTy = PremultipliedAlpha<EncodedSrgb<u8>>;
  method from (line 82) | fn from(srgba: PremultipliedAlpha<LinearSrgb<f32>>) -> Self {
  function from (line 93) | fn from(col: Rgba) -> Self {
  type CintTy (line 104) | type CintTy = PremultipliedAlpha<LinearSrgb<f32>>;
  method from (line 110) | fn from(srgba: Alpha<Hsv<f32>>) -> Self {
  function from (line 121) | fn from(col: Hsva) -> Self {
  type CintTy (line 132) | type CintTy = Alpha<Hsv<f32>>;
  type CintTy (line 138) | type CintTy = Alpha<Hsv<f32>>;
  method from (line 142) | fn from(srgba: Alpha<Hsv<f32>>) -> Self {
  function from (line 153) | fn from(col: HsvaGamma) -> Self {

FILE: crates/ecolor/src/color32.rs
  type Color32 (line 31) | pub struct Color32(pub(crate) [u8; 4]);
    method fmt (line 35) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    type Output (line 42) | type Output = u8;
    method index (line 45) | fn index(&self, index: usize) -> &u8 {
    method index_mut (line 52) | fn index_mut(&mut self, index: usize) -> &mut u8 {
    constant TRANSPARENT (line 60) | pub const TRANSPARENT: Self = Self::from_rgba_premultiplied(0, 0, 0, 0);
    constant BLACK (line 61) | pub const BLACK: Self = Self::from_rgb(0, 0, 0);
    constant DARK_GRAY (line 63) | pub const DARK_GRAY: Self = Self::from_rgb(96, 96, 96);
    constant GRAY (line 65) | pub const GRAY: Self = Self::from_rgb(160, 160, 160);
    constant LIGHT_GRAY (line 67) | pub const LIGHT_GRAY: Self = Self::from_rgb(220, 220, 220);
    constant WHITE (line 68) | pub const WHITE: Self = Self::from_rgb(255, 255, 255);
    constant BROWN (line 70) | pub const BROWN: Self = Self::from_rgb(165, 42, 42);
    constant DARK_RED (line 71) | pub const DARK_RED: Self = Self::from_rgb(0x8B, 0, 0);
    constant RED (line 72) | pub const RED: Self = Self::from_rgb(255, 0, 0);
    constant LIGHT_RED (line 73) | pub const LIGHT_RED: Self = Self::from_rgb(255, 128, 128);
    constant CYAN (line 75) | pub const CYAN: Self = Self::from_rgb(0, 255, 255);
    constant MAGENTA (line 76) | pub const MAGENTA: Self = Self::from_rgb(255, 0, 255);
    constant YELLOW (line 77) | pub const YELLOW: Self = Self::from_rgb(255, 255, 0);
    constant ORANGE (line 79) | pub const ORANGE: Self = Self::from_rgb(255, 165, 0);
    constant LIGHT_YELLOW (line 80) | pub const LIGHT_YELLOW: Self = Self::from_rgb(255, 255, 0xE0);
    constant KHAKI (line 81) | pub const KHAKI: Self = Self::from_rgb(240, 230, 140);
    constant DARK_GREEN (line 83) | pub const DARK_GREEN: Self = Self::from_rgb(0, 0x64, 0);
    constant GREEN (line 84) | pub const GREEN: Self = Self::from_rgb(0, 255, 0);
    constant LIGHT_GREEN (line 85) | pub const LIGHT_GREEN: Self = Self::from_rgb(0x90, 0xEE, 0x90);
    constant DARK_BLUE (line 87) | pub const DARK_BLUE: Self = Self::from_rgb(0, 0, 0x8B);
    constant BLUE (line 88) | pub const BLUE: Self = Self::from_rgb(0, 0, 255);
    constant LIGHT_BLUE (line 89) | pub const LIGHT_BLUE: Self = Self::from_rgb(0xAD, 0xD8, 0xE6);
    constant PURPLE (line 91) | pub const PURPLE: Self = Self::from_rgb(0x80, 0, 0x80);
    constant GOLD (line 93) | pub const GOLD: Self = Self::from_rgb(255, 215, 0);
    constant DEBUG_COLOR (line 95) | pub const DEBUG_COLOR: Self = Self::from_rgba_premultiplied(0, 200, 0,...
    constant PLACEHOLDER (line 104) | pub const PLACEHOLDER: Self = Self::from_rgba_premultiplied(64, 254, 0...
    method from_rgb (line 108) | pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
    method from_rgb_additive (line 114) | pub const fn from_rgb_additive(r: u8, g: u8, b: u8) -> Self {
    method from_rgba_premultiplied (line 122) | pub const fn from_rgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Se...
    method from_rgba_unmultiplied (line 133) | pub fn from_rgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
    method from_rgba_unmultiplied_const (line 164) | pub const fn from_rgba_unmultiplied_const(r: u8, g: u8, b: u8, a: u8) ...
    method from_gray (line 184) | pub const fn from_gray(l: u8) -> Self {
    method from_black_alpha (line 190) | pub const fn from_black_alpha(a: u8) -> Self {
    method from_white_alpha (line 196) | pub fn from_white_alpha(a: u8) -> Self {
    method from_additive_luminance (line 202) | pub const fn from_additive_luminance(l: u8) -> Self {
    method is_opaque (line 207) | pub const fn is_opaque(&self) -> bool {
    method r (line 213) | pub const fn r(&self) -> u8 {
    method g (line 219) | pub const fn g(&self) -> u8 {
    method b (line 225) | pub const fn b(&self) -> u8 {
    method a (line 231) | pub const fn a(&self) -> u8 {
    method to_opaque (line 237) | pub fn to_opaque(self) -> Self {
    method additive (line 243) | pub const fn additive(self) -> Self {
    method is_additive (line 250) | pub fn is_additive(self) -> bool {
    method to_array (line 256) | pub const fn to_array(&self) -> [u8; 4] {
    method to_tuple (line 262) | pub const fn to_tuple(&self) -> (u8, u8, u8, u8) {
    method to_srgba_unmultiplied (line 273) | pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
    method gamma_multiply (line 294) | pub fn gamma_multiply(self, factor: f32) -> Self {
    method gamma_multiply_u8 (line 314) | pub fn gamma_multiply_u8(self, factor: u8) -> Self {
    method linear_multiply (line 330) | pub fn linear_multiply(self, factor: f32) -> Self {
    method to_normalized_gamma_f32 (line 345) | pub fn to_normalized_gamma_f32(self) -> [f32; 4] {
    method lerp_to_gamma (line 356) | pub fn lerp_to_gamma(&self, other: Self, t: f32) -> Self {
    method blend (line 368) | pub fn blend(self, on_top: Self) -> Self {
    method intensity (line 376) | pub fn intensity(&self) -> f32 {
    type Output (line 382) | type Output = Self;
    method mul (line 386) | fn mul(self, other: Self) -> Self {
    type Output (line 397) | type Output = Self;
    method add (line 400) | fn add(self, other: Self) -> Self {
  function test_rgba (line 414) | fn test_rgba() -> impl Iterator<Item = [u8; 4]> {
  function test_color32_additive (line 436) | fn test_color32_additive() {
  function test_color32_blend_vs_gamma_blend (line 448) | fn test_color32_blend_vs_gamma_blend() {
  function color32_unmultiplied_round_trip (line 477) | fn color32_unmultiplied_round_trip() {
  function from_black_white_alpha (line 500) | fn from_black_white_alpha() {
  function to_from_rgba (line 523) | fn to_from_rgba() {

FILE: crates/ecolor/src/hex_color_macro.rs
  function test_from_rgb_hex (line 53) | fn test_from_rgb_hex() {
  function test_from_rgba_hex (line 65) | fn test_from_rgba_hex() {

FILE: crates/ecolor/src/hex_color_runtime.rs
  type HexColor (line 16) | pub enum HexColor {
    method color (line 75) | pub fn color(&self) -> Color32 {
    method from_str_without_hash (line 87) | pub fn from_str_without_hash(s: &str) -> Result<Self, ParseHexColorErr...
  type ParseHexColorError (line 31) | pub enum ParseHexColorError {
  type Err (line 38) | type Err = ParseHexColorError;
  method from_str (line 40) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method fmt (line 48) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method from_hex (line 143) | pub fn from_hex(hex: &str) -> Result<Self, ParseHexColorError> {
  method to_hex (line 162) | pub fn to_hex(&self) -> String {
  function hex_string_formats (line 172) | fn hex_string_formats() {
  function hex_string_round_trip (line 210) | fn hex_string_round_trip() {

FILE: crates/ecolor/src/hsva.rs
  type Hsva (line 9) | pub struct Hsva {
    method new (line 25) | pub fn new(h: f32, s: f32, v: f32, a: f32) -> Self {
    method from_srgba_premultiplied (line 31) | pub fn from_srgba_premultiplied([r, g, b, a]: [u8; 4]) -> Self {
    method from_srgba_unmultiplied (line 37) | pub fn from_srgba_unmultiplied([r, g, b, a]: [u8; 4]) -> Self {
    method from_rgba_premultiplied (line 43) | pub fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
    method from_rgba_unmultiplied (line 59) | pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
    method from_additive_rgb (line 66) | pub fn from_additive_rgb(rgb: [f32; 3]) -> Self {
    method from_additive_srgb (line 77) | pub fn from_additive_srgb([r, g, b]: [u8; 3]) -> Self {
    method from_rgb (line 86) | pub fn from_rgb(rgb: [f32; 3]) -> Self {
    method from_srgb (line 92) | pub fn from_srgb([r, g, b]: [u8; 3]) -> Self {
    method to_opaque (line 103) | pub fn to_opaque(self) -> Self {
    method to_rgb (line 108) | pub fn to_rgb(&self) -> [f32; 3] {
    method to_srgb (line 113) | pub fn to_srgb(&self) -> [u8; 3] {
    method to_rgba_premultiplied (line 123) | pub fn to_rgba_premultiplied(&self) -> [f32; 4] {
    method to_rgba_unmultiplied (line 137) | pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
    method to_srgba_premultiplied (line 144) | pub fn to_srgba_premultiplied(&self) -> [u8; 4] {
    method to_srgba_unmultiplied (line 150) | pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
    method from (line 170) | fn from(rgba: Rgba) -> Self {
    method from (line 184) | fn from(srgba: Color32) -> Self {
  method from (line 163) | fn from(hsva: Hsva) -> Self {
  method from (line 177) | fn from(hsva: Hsva) -> Self {
  function hsv_from_rgb (line 191) | pub fn hsv_from_rgb([r, g, b]: [f32; 3]) -> (f32, f32, f32) {
  function rgb_from_hsv (line 215) | pub fn rgb_from_hsv((h, s, v): (f32, f32, f32)) -> [f32; 3] {
  function test_hsv_roundtrip (line 238) | fn test_hsv_roundtrip() {

FILE: crates/ecolor/src/hsva_gamma.rs
  type HsvaGamma (line 6) | pub struct HsvaGamma {
    method from (line 45) | fn from(rgba: Rgba) -> Self {
    method from (line 51) | fn from(srgba: Color32) -> Self {
    method from (line 57) | fn from(hsva: Hsva) -> Self {
  method from (line 21) | fn from(hsvag: HsvaGamma) -> Self {
  method from (line 27) | fn from(hsvag: HsvaGamma) -> Self {
  method from (line 33) | fn from(hsvag: HsvaGamma) -> Self {

FILE: crates/ecolor/src/lib.rs
  method from (line 52) | fn from(srgba: Color32) -> Self {
  method from (line 75) | fn from(rgba: Rgba) -> Self {
  function linear_f32_from_gamma_u8 (line 97) | pub fn linear_f32_from_gamma_u8(s: u8) -> f32 {
  function linear_f32_from_linear_u8 (line 108) | pub const fn linear_f32_from_linear_u8(a: u8) -> f32 {
  function gamma_u8_from_linear_f32 (line 114) | pub fn gamma_u8_from_linear_f32(l: f32) -> u8 {
  function linear_u8_from_linear_f32 (line 129) | pub fn linear_u8_from_linear_f32(a: f32) -> u8 {
  function fast_round (line 133) | const fn fast_round(r: f32) -> u8 {
  function test_srgba_conversion (line 138) | pub fn test_srgba_conversion() {
  function linear_from_gamma (line 148) | pub fn linear_from_gamma(gamma: f32) -> f32 {
  function gamma_from_linear (line 160) | pub fn gamma_from_linear(linear: f32) -> f32 {
  function tint_color_towards (line 174) | pub fn tint_color_towards(color: Color32, target: Color32) -> Color32 {

FILE: crates/ecolor/src/rgba.rs
  type Rgba (line 10) | pub struct Rgba(pub(crate) [f32; 4]);
    type Output (line 13) | type Output = f32;
    method index (line 16) | fn index(&self, index: usize) -> &f32 {
    method index_mut (line 23) | fn index_mut(&mut self, index: usize) -> &mut f32 {
    method hash (line 43) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
    constant TRANSPARENT (line 52) | pub const TRANSPARENT: Self = Self::from_rgba_premultiplied(0.0, 0.0, ...
    constant BLACK (line 53) | pub const BLACK: Self = Self::from_rgb(0.0, 0.0, 0.0);
    constant WHITE (line 54) | pub const WHITE: Self = Self::from_rgb(1.0, 1.0, 1.0);
    constant RED (line 55) | pub const RED: Self = Self::from_rgb(1.0, 0.0, 0.0);
    constant GREEN (line 56) | pub const GREEN: Self = Self::from_rgb(0.0, 1.0, 0.0);
    constant BLUE (line 57) | pub const BLUE: Self = Self::from_rgb(0.0, 0.0, 1.0);
    method from_rgba_premultiplied (line 60) | pub const fn from_rgba_premultiplied(r: f32, g: f32, b: f32, a: f32) -...
    method from_rgba_unmultiplied (line 65) | pub fn from_rgba_unmultiplied(r: f32, g: f32, b: f32, a: f32) -> Self {
    method from_srgba_premultiplied (line 70) | pub fn from_srgba_premultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
    method from_srgba_unmultiplied (line 75) | pub fn from_srgba_unmultiplied(r: u8, g: u8, b: u8, a: u8) -> Self {
    method from_rgb (line 80) | pub const fn from_rgb(r: f32, g: f32, b: f32) -> Self {
    method from_gray (line 86) | pub const fn from_gray(l: f32) -> Self {
    method from_luminance_alpha (line 91) | pub fn from_luminance_alpha(l: f32, a: f32) -> Self {
    method from_black_alpha (line 105) | pub fn from_black_alpha(a: f32) -> Self {
    method from_white_alpha (line 115) | pub fn from_white_alpha(a: f32) -> Self {
    method additive (line 122) | pub fn additive(self) -> Self {
    method is_additive (line 129) | pub fn is_additive(self) -> bool {
    method multiply (line 135) | pub fn multiply(self, alpha: f32) -> Self {
    method r (line 145) | pub fn r(&self) -> f32 {
    method g (line 150) | pub fn g(&self) -> f32 {
    method b (line 155) | pub fn b(&self) -> f32 {
    method a (line 160) | pub fn a(&self) -> f32 {
    method intensity (line 166) | pub fn intensity(&self) -> f32 {
    method to_opaque (line 172) | pub fn to_opaque(&self) -> Self {
    method to_array (line 188) | pub fn to_array(&self) -> [f32; 4] {
    method to_tuple (line 194) | pub fn to_tuple(&self) -> (f32, f32, f32, f32) {
    method to_rgba_unmultiplied (line 200) | pub fn to_rgba_unmultiplied(&self) -> [f32; 4] {
    method to_srgba_unmultiplied (line 212) | pub fn to_srgba_unmultiplied(&self) -> [u8; 4] {
    method blend (line 217) | pub fn blend(self, on_top: Self) -> Self {
    type Output (line 223) | type Output = Self;
    method add (line 226) | fn add(self, rhs: Self) -> Self {
    type Output (line 237) | type Output = Self;
    method mul (line 240) | fn mul(self, other: Self) -> Self {
    type Output (line 251) | type Output = Self;
    method mul (line 254) | fn mul(self, factor: f32) -> Self {
  function f32_hash (line 30) | pub(crate) fn f32_hash<H: std::hash::Hasher>(state: &mut H, f: f32) {
  type Output (line 265) | type Output = Rgba;
  function mul (line 268) | fn mul(self, rgba: Rgba) -> Rgba {
  function test_rgba (line 283) | fn test_rgba() -> impl Iterator<Item = [u8; 4]> {
  function test_rgba_blend (line 305) | fn test_rgba_blend() {
  function test_rgba_roundtrip (line 325) | fn test_rgba_roundtrip() {

FILE: crates/eframe/src/epi.rs
  type EventLoopBuilderHook (line 34) | pub type EventLoopBuilderHook = Box<dyn FnOnce(&mut EventLoopBuilder<Use...
  type WindowBuilderHook (line 42) | pub type WindowBuilderHook = Box<dyn FnOnce(egui::ViewportBuilder) -> eg...
  type DynError (line 44) | type DynError = Box<dyn std::error::Error + Send + Sync>;
  type AppCreator (line 49) | pub type AppCreator<'app> =
  type CreationContext (line 53) | pub struct CreationContext<'s> {
  method window_handle (line 98) | fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
  method display_handle (line 107) | fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
  function _new_kittest (line 116) | pub fn _new_kittest(egui_ctx: egui::Context) -> Self {
  type App (line 138) | pub trait App {
    method logic (line 147) | fn logic(&mut self, ctx: &egui::Context, frame: &mut Frame) {
    method ui (line 162) | fn ui(&mut self, ui: &mut egui::Ui, frame: &mut Frame);
    method update (line 176) | fn update(&mut self, ctx: &egui::Context, frame: &mut Frame) {
    method as_any_mut (line 196) | fn as_any_mut(&mut self) -> Option<&mut dyn Any> {
    method save (line 208) | fn save(&mut self, _storage: &mut dyn Storage) {}
    method on_exit (line 218) | fn on_exit(&mut self, _gl: Option<&glow::Context>) {}
    method on_exit (line 224) | fn on_exit(&mut self) {}
    method auto_save_interval (line 230) | fn auto_save_interval(&self) -> std::time::Duration {
    method clear_color (line 244) | fn clear_color(&self, _visuals: &egui::Visuals) -> [f32; 4] {
    method persist_egui_memory (line 255) | fn persist_egui_memory(&self) -> bool {
    method raw_input_hook (line 275) | fn raw_input_hook(&mut self, _ctx: &egui::Context, _raw_input: &mut eg...
  type HardwareAcceleration (line 281) | pub enum HardwareAcceleration {
  type NativeOptions (line 308) | pub struct NativeOptions {
  method clone (line 432) | fn clone(&self) -> Self {
  method default (line 457) | fn default() -> Self {
  type WebOptions (line 502) | pub struct WebOptions {
  method default (line 553) | fn default() -> Self {
  type WebGlContextOption (line 581) | pub enum WebGlContextOption {
  type Renderer (line 604) | pub enum Renderer {
    method fmt (line 641) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    type Err (line 654) | type Err = String;
    method from_str (line 656) | fn from_str(name: &str) -> Result<Self, String> {
  method default (line 616) | fn default() -> Self {
  type Frame (line 677) | pub struct Frame {
    method _new_kittest (line 732) | pub fn _new_kittest() -> Self {
    method is_web (line 753) | pub fn is_web(&self) -> bool {
    method info (line 758) | pub fn info(&self) -> &IntegrationInfo {
    method storage (line 763) | pub fn storage(&self) -> Option<&dyn Storage> {
    method storage_mut (line 768) | pub fn storage_mut(&mut self) -> Option<&mut (dyn Storage + 'static)> {
    method gl (line 785) | pub fn gl(&self) -> Option<&std::sync::Arc<glow::Context>> {
    method register_native_glow_texture (line 794) | pub fn register_native_glow_texture(&mut self, native: glow::Texture) ...
    method wgpu_render_state (line 805) | pub fn wgpu_render_state(&self) -> Option<&egui_wgpu::RenderState> {
  method window_handle (line 714) | fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError> {
  method display_handle (line 723) | fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
  type WebInfo (line 813) | pub struct WebInfo {
  type Location (line 826) | pub struct Location {
  type IntegrationInfo (line 878) | pub struct IntegrationInfo {
    method mock (line 894) | fn mock() -> Self {
  type Storage (line 924) | pub trait Storage {
    method get_string (line 926) | fn get_string(&self, key: &str) -> Option<String>;
    method set_string (line 929) | fn set_string(&mut self, key: &str, value: String);
    method flush (line 932) | fn flush(&mut self);
  function get_value (line 937) | pub fn get_value<T: serde::de::DeserializeOwned>(storage: &dyn Storage, ...
  function set_value (line 952) | pub fn set_value<T: serde::Serialize>(storage: &mut dyn Storage, key: &s...
  constant APP_KEY (line 961) | pub const APP_KEY: &str = "app";

FILE: crates/eframe/src/icon_data.rs
  type IconDataExt (line 6) | pub trait IconDataExt {
    method to_image (line 11) | fn to_image(&self) -> Result<image::RgbaImage, String>;
    method to_png_bytes (line 17) | fn to_png_bytes(&self) -> Result<Vec<u8>, String>;
    method to_image (line 40) | fn to_image(&self) -> Result<image::RgbaImage, String> {
    method to_png_bytes (line 50) | fn to_png_bytes(&self) -> Result<Vec<u8>, String> {
  function from_png_bytes (line 24) | pub fn from_png_bytes(png_bytes: &[u8]) -> Result<IconData, image::Image...
  function from_image (line 30) | fn from_image(image: image::DynamicImage) -> IconData {

FILE: crates/eframe/src/lib.rs
  function run_native (line 256) | pub fn run_native(
  function create_native (line 325) | pub fn create_native<'a>(
  function init_native (line 360) | fn init_native(app_name: &str, native_options: &mut NativeOptions) -> Re...
  function run_ui_native (line 424) | pub fn run_ui_native(
  function run_simple_native (line 483) | pub fn run_simple_native(
  type Error (line 511) | pub enum Error {
    method from (line 545) | fn from(err: winit::error::OsError) -> Self {
    method from (line 553) | fn from(err: winit::error::EventLoopError) -> Self {
    method from (line 561) | fn from(err: glutin::error::Error) -> Self {
    method from (line 569) | fn from(err: egui_glow::PainterError) -> Self {
    method from (line 577) | fn from(err: egui_wgpu::WgpuError) -> Self {
    method fmt (line 583) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Result (line 624) | pub type Result<T = (), E = Error> = std::result::Result<T, E>;

FILE: crates/eframe/src/native/app_icon.rs
  type AppTitleIconSetter (line 9) | pub struct AppTitleIconSetter {
    method new (line 16) | pub fn new(title: String, mut icon_data: Option<Arc<IconData>>) -> Self {
    method update (line 31) | pub fn update(&mut self) {
  type AppIconStatus (line 40) | enum AppIconStatus {
  function set_title_and_icon (line 61) | fn set_title_and_icon(_title: &str, _icon_data: Option<&IconData>) -> Ap...
  function set_app_icon_windows (line 81) | fn set_app_icon_windows(icon_data: &IconData) -> AppIconStatus {
  function set_title_and_icon_mac (line 203) | fn set_title_and_icon_mac(title: &str, icon_data: Option<&IconData>) -> ...

FILE: crates/eframe/src/native/epi_integration.rs
  function viewport_builder (line 16) | pub fn viewport_builder(
  function apply_window_settings (line 92) | pub fn apply_window_settings(
  function largest_monitor_point_size (line 103) | fn largest_monitor_point_size(egui_zoom_factor: f32, event_loop: &Active...
  function create_storage (line 130) | pub fn create_storage(_app_name: &str) -> Option<Box<dyn epi::Storage>> {
  function create_storage_with_file (line 139) | pub fn create_storage_with_file(_file: impl Into<PathBuf>) -> Option<Box...
  type EpiIntegration (line 153) | pub struct EpiIntegration {
    method new (line 172) | pub fn new(
    method should_close (line 230) | pub fn should_close(&self) -> bool {
    method on_window_event (line 234) | pub fn on_window_event(
    method pre_update (line 256) | pub fn pre_update(&mut self) {
    method update (line 263) | pub fn update(
    method report_frame_time (line 321) | pub fn report_frame_time(&mut self, seconds: f32) {
    method post_rendering (line 325) | pub fn post_rendering(&mut self, window: &winit::window::Window) {
    method maybe_autosave (line 336) | pub fn maybe_autosave(
    method save (line 348) | pub fn save(&mut self, app: &mut dyn epi::App, window: Option<&winit::...
  function load_default_egui_icon (line 382) | fn load_default_egui_icon() -> egui::IconData {
  constant STORAGE_EGUI_MEMORY_KEY (line 389) | const STORAGE_EGUI_MEMORY_KEY: &str = "egui";
  constant STORAGE_WINDOW_KEY (line 392) | const STORAGE_WINDOW_KEY: &str = "window";
  function load_window_settings (line 394) | pub fn load_window_settings(_storage: Option<&dyn epi::Storage>) -> Opti...
  function load_egui_memory (line 404) | pub fn load_egui_memory(_storage: Option<&dyn epi::Storage>) -> Option<e...

FILE: crates/eframe/src/native/event_loop_context.rs
  type EventLoopGuard (line 8) | struct EventLoopGuard;
    method new (line 11) | fn new(event_loop: &ActiveEventLoop) -> Self {
  method drop (line 24) | fn drop(&mut self) {
  function with_current_event_loop (line 31) | pub fn with_current_event_loop<F, R>(f: F) -> Option<R>
  function with_event_loop_context (line 50) | pub fn with_event_loop_context(event_loop: &ActiveEventLoop, f: impl FnO...

FILE: crates/eframe/src/native/file_storage.rs
  function storage_dir (line 17) | pub fn storage_dir(app_id: &str) -> Option<PathBuf> {
  function roaming_appdata (line 46) | fn roaming_appdata() -> Option<PathBuf> {
  function roaming_appdata (line 92) | fn roaming_appdata() -> Option<PathBuf> {
  type FileStorage (line 100) | pub struct FileStorage {
    method from_ron_filepath (line 118) | pub(crate) fn from_ron_filepath(ron_filepath: impl Into<PathBuf>) -> S...
    method from_app_id (line 131) | pub fn from_app_id(app_id: &str) -> Option<Self> {
    method get_string (line 151) | fn get_string(&self, key: &str) -> Option<String> {
    method set_string (line 155) | fn set_string(&mut self, key: &str, value: String) {
    method flush (line 162) | fn flush(&mut self) {
  method drop (line 108) | fn drop(&mut self) {
  function save_to_disk (line 192) | fn save_to_disk(file_path: &PathBuf, kv: &HashMap<String, String>) {
  function read_ron (line 225) | fn read_ron<T>(ron_path: impl AsRef<Path>) -> Option<T>
  function directories_storage_dir (line 252) | fn directories_storage_dir(app_id: &str) -> Option<PathBuf> {
  function storage_path_matches_directories (line 258) | fn storage_path_matches_directories() {

FILE: crates/eframe/src/native/glow_integration.rs
  type GlowWinitApp (line 48) | pub struct GlowWinitApp<'app> {
  type GlowWinitRunning (line 63) | struct GlowWinitRunning<'app> {
  type GlutinWindowContext (line 87) | struct GlutinWindowContext {
    method new (line 940) | unsafe fn new(
    method initialize_all_windows (line 1132) | fn initialize_all_windows(&mut self, event_loop: &ActiveEventLoop) {
    method initialize_window (line 1146) | pub(crate) fn initialize_window(
    method on_suspend (line 1257) | fn on_suspend(&mut self) -> Result {
    method viewport (line 1272) | fn viewport(&self, viewport_id: ViewportId) -> &Viewport {
    method window_opt (line 1278) | fn window_opt(&self, viewport_id: ViewportId) -> Option<Arc<Window>> {
    method window (line 1282) | fn window(&self, viewport_id: ViewportId) -> Arc<Window> {
    method resize (line 1287) | fn resize(&mut self, viewport_id: ViewportId, physical_size: winit::dp...
    method get_proc_address (line 1309) | fn get_proc_address(&self, addr: &std::ffi::CStr) -> *const std::ffi::...
    method remove_viewports_not_in (line 1313) | pub(crate) fn remove_viewports_not_in(
    method handle_viewport_output (line 1326) | fn handle_viewport_output(
  type Viewport (line 105) | struct Viewport {
  function new (line 127) | pub fn new(
  function create_glutin_windowed_context (line 144) | fn create_glutin_windowed_context(
  function init_run_state (line 194) | fn init_run_state(
  method egui_ctx (line 349) | fn egui_ctx(&self) -> Option<&egui::Context> {
  method window (line 353) | fn window(&self, window_id: WindowId) -> Option<Arc<Window>> {
  method window_id_from_viewport_id (line 364) | fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId> {
  method save (line 374) | fn save(&mut self) {
  method save_and_destroy (line 388) | fn save_and_destroy(&mut self) {
  method run_ui_and_paint (line 401) | fn run_ui_and_paint(
  method resumed (line 413) | fn resumed(&mut self, event_loop: &ActiveEventLoop) -> crate::Result<Eve...
  method suspended (line 431) | fn suspended(&mut self, _: &ActiveEventLoop) -> crate::Result<EventResul...
  method device_event (line 438) | fn device_event(
  method window_event (line 474) | fn window_event(
  method on_accesskit_event (line 488) | fn on_accesskit_event(&mut self, event: accesskit_winit::Event) -> crate...
  function run_ui_and_paint (line 510) | fn run_ui_and_paint(
  function on_window_event (line 778) | fn on_window_event(
  function change_gl_context (line 902) | fn change_gl_context(
  function initialize_or_update_viewport (line 1386) | fn initialize_or_update_viewport(
  function render_immediate_viewport (line 1452) | fn render_immediate_viewport(
  function save_screenshot_and_exit (line 1596) | fn save_screenshot_and_exit(

FILE: crates/eframe/src/native/run.rs
  function create_event_loop (line 18) | fn create_event_loop(native_options: &mut epi::NativeOptions) -> Result<...
  function with_event_loop (line 46) | fn with_event_loop<R>(
  type WinitAppWrapper (line 68) | struct WinitAppWrapper<T: WinitApp> {
  function new (line 76) | fn new(winit_app: T, run_and_return: bool) -> Self {
  function handle_event_result (line 85) | fn handle_event_result(
  function check_redraw_requests (line 177) | fn check_redraw_requests(&mut self, event_loop: &ActiveEventLoop) {
  function suspended (line 205) | fn suspended(&mut self, event_loop: &ActiveEventLoop) {
  function resumed (line 214) | fn resumed(&mut self, event_loop: &ActiveEventLoop) {
  function exiting (line 224) | fn exiting(&mut self, event_loop: &ActiveEventLoop) {
  function device_event (line 233) | fn device_event(
  function user_event (line 248) | fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
  function new_events (line 291) | fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: winit::eve...
  function window_event (line 299) | fn window_event(
  function run_and_return (line 322) | fn run_and_return(event_loop: &mut EventLoop<UserEvent>, winit_app: impl...
  function run_and_exit (line 333) | fn run_and_exit(event_loop: EventLoop<UserEvent>, winit_app: impl WinitA...
  function run_glow (line 347) | pub fn run_glow(
  function create_glow (line 368) | pub fn create_glow<'a>(
  function run_wgpu (line 383) | pub fn run_wgpu(
  function create_wgpu (line 404) | pub fn create_wgpu<'a>(
  type EframeWinitApplication (line 422) | pub struct EframeWinitApplication<'a> {
  function resumed (line 428) | fn resumed(&mut self, event_loop: &ActiveEventLoop) {
  function window_event (line 432) | fn window_event(
  function new_events (line 441) | fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: winit::eve...
  function user_event (line 445) | fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
  function device_event (line 449) | fn device_event(
  function about_to_wait (line 458) | fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
  function suspended (line 463) | fn suspended(&mut self, event_loop: &ActiveEventLoop) {
  function exiting (line 467) | fn exiting(&mut self, event_loop: &ActiveEventLoop) {
  function memory_warning (line 471) | fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
  function new (line 477) | pub(crate) fn new<T: ApplicationHandler<UserEvent> + 'a>(app: T) -> Self {
  function pump_eframe_app (line 492) | pub fn pump_eframe_app(
  type EframePumpStatus (line 510) | pub enum EframePumpStatus {

FILE: crates/eframe/src/native/wgpu_integration.rs
  type WgpuWinitApp (line 38) | pub struct WgpuWinitApp<'app> {
  type WgpuWinitRunning (line 53) | struct WgpuWinitRunning<'app> {
  type SharedState (line 68) | pub struct SharedState {
  type Viewports (line 77) | pub type Viewports = egui::OrderedViewportIdMap<Viewport>;
  type Viewport (line 79) | pub struct Viewport {
    method initialize_window (line 930) | fn initialize_window(
  function new (line 101) | pub fn new(
  function initialized_all_windows (line 125) | fn initialized_all_windows(&mut self, event_loop: &ActiveEventLoop) {
  function recreate_window (line 148) | fn recreate_window(&self, event_loop: &ActiveEventLoop, running: &WgpuWi...
  function drop_window (line 169) | fn drop_window(&mut self) -> Result<(), egui_wgpu::WgpuError> {
  function init_run_state (line 178) | fn init_run_state(
  method egui_ctx (line 345) | fn egui_ctx(&self) -> Option<&egui::Context> {
  method window (line 349) | fn window(&self, window_id: WindowId) -> Option<Arc<Window>> {
  method window_id_from_viewport_id (line 360) | fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId> {
  method save (line 374) | fn save(&mut self) {
  method save_and_destroy (line 381) | fn save_and_destroy(&mut self) {
  method run_ui_and_paint (line 387) | fn run_ui_and_paint(
  method resumed (line 401) | fn resumed(&mut self, event_loop: &ActiveEventLoop) -> crate::Result<Eve...
  method suspended (line 438) | fn suspended(&mut self, _: &ActiveEventLoop) -> crate::Result<EventResul...
  method device_event (line 444) | fn device_event(
  method window_event (line 480) | fn window_event(
  method on_accesskit_event (line 497) | fn on_accesskit_event(&mut self, event: accesskit_winit::Event) -> crate...
  function save (line 524) | fn save(&mut self) {
  function save_and_destroy (line 536) | fn save_and_destroy(&mut self) {
  function run_ui_and_paint (line 552) | fn run_ui_and_paint(&mut self, window_id: WindowId) -> Result<EventResul...
  function on_window_event (line 788) | fn on_window_event(
  function create_window (line 976) | fn create_window(
  function render_immediate_viewport (line 998) | fn render_immediate_viewport(
  function remove_viewports_not_in (line 1114) | pub(crate) fn remove_viewports_not_in(
  function handle_viewport_output (line 1129) | fn handle_viewport_output(
  function initialize_or_update_viewport (line 1184) | fn initialize_or_update_viewport<'a>(

FILE: crates/eframe/src/native/winit_integration.rs
  function create_egui_context (line 13) | pub fn create_egui_context(storage: Option<&dyn crate::Storage>) -> egui...
  type UserEvent (line 44) | pub enum UserEvent {
    method from (line 64) | fn from(inner: accesskit_winit::Event) -> Self {
  type WinitApp (line 69) | pub trait WinitApp {
    method egui_ctx (line 70) | fn egui_ctx(&self) -> Option<&egui::Context>;
    method window (line 72) | fn window(&self, window_id: WindowId) -> Option<Arc<Window>>;
    method window_id_from_viewport_id (line 74) | fn window_id_from_viewport_id(&self, id: ViewportId) -> Option<WindowId>;
    method save (line 76) | fn save(&mut self);
    method save_and_destroy (line 78) | fn save_and_destroy(&mut self);
    method run_ui_and_paint (line 80) | fn run_ui_and_paint(
    method suspended (line 86) | fn suspended(&mut self, event_loop: &ActiveEventLoop) -> crate::Result...
    method resumed (line 88) | fn resumed(&mut self, event_loop: &ActiveEventLoop) -> crate::Result<E...
    method device_event (line 90) | fn device_event(
    method window_event (line 97) | fn window_event(
    method on_accesskit_event (line 105) | fn on_accesskit_event(&mut self, event: accesskit_winit::Event) -> cra...
  type EventResult (line 109) | pub enum EventResult {
  function on_accesskit_window_event (line 153) | pub(crate) fn on_accesskit_window_event(

FILE: crates/eframe/src/stopwatch.rs
  type Stopwatch (line 5) | pub struct Stopwatch {
    method new (line 13) | pub fn new() -> Self {
    method start (line 20) | pub fn start(&mut self) {
    method pause (line 25) | pub fn pause(&mut self) {
    method resume (line 31) | pub fn resume(&mut self) {
    method total_time_ns (line 36) | pub fn total_time_ns(&self) -> u128 {
    method total_time_sec (line 47) | pub fn total_time_sec(&self) -> f32 {

FILE: crates/eframe/src/web/app_runner.rs
  type AppRunner (line 9) | pub struct AppRunner {
    method new (line 43) | pub async fn new(
    method egui_ctx (line 179) | pub fn egui_ctx(&self) -> &egui::Context {
    method app_mut (line 186) | pub fn app_mut<ConcreteApp: 'static + App>(&mut self) -> &mut Concrete...
    method auto_save_if_needed (line 194) | pub fn auto_save_if_needed(&mut self) {
    method save (line 201) | pub fn save(&mut self) {
    method canvas (line 211) | pub fn canvas(&self) -> &web_sys::HtmlCanvasElement {
    method destroy (line 215) | pub fn destroy(mut self) {
    method has_outstanding_paint_data (line 220) | pub fn has_outstanding_paint_data(&self) -> bool {
    method has_focus (line 227) | pub fn has_focus(&self) -> bool {
    method update_focus (line 237) | pub fn update_focus(&mut self) {
    method logic (line 254) | pub fn logic(&mut self) {
    method paint (line 329) | pub fn paint(&mut self) {
    method report_frame_time (line 361) | pub fn report_frame_time(&mut self, cpu_usage_seconds: f32) {
    method handle_platform_output (line 365) | fn handle_platform_output(&self, platform_output: egui::PlatformOutput) {
  method drop (line 31) | fn drop(&mut self) {
  type LocalStorage (line 425) | struct LocalStorage {}
    method get_string (line 428) | fn get_string(&self, key: &str) -> Option<String> {
    method set_string (line 432) | fn set_string(&mut self, key: &str, value: String) {
    method flush (line 436) | fn flush(&mut self) {}

FILE: crates/eframe/src/web/backend.rs
  type WebInput (line 13) | pub(crate) struct WebInput {
    method new_frame (line 28) | pub fn new_frame(&mut self, canvas_size: egui::Vec2) -> egui::RawInput {
    method set_focus (line 50) | pub fn set_focus(&mut self, focused: bool) {
  type NeedRepaint (line 66) | pub(crate) struct NeedRepaint {
    method new (line 75) | pub fn new(max_fps: Option<u32>) -> Self {
    method when_to_repaint (line 86) | pub fn when_to_repaint(&self) -> f64 {
    method clear (line 91) | pub fn clear(&self) {
    method repaint_after (line 95) | pub fn repaint_after(&self, num_seconds: f64) {
    method repaint (line 103) | pub fn repaint(&self) {
    method repaint_asap (line 109) | pub fn repaint_asap(&self) {
    method needs_repaint (line 113) | pub fn needs_repaint(&self) -> bool {
    method round_repaint_time_to_rate (line 117) | fn round_repaint_time_to_rate(&self, time: f64) -> f64 {
  function user_agent (line 130) | pub fn user_agent() -> Option<String> {
  function web_location (line 135) | pub fn web_location() -> epi::Location {
  function parse_query_map (line 162) | fn parse_query_map(query: &str) -> BTreeMap<String, Vec<String>> {
  function test_parse_query (line 184) | fn test_parse_query() {

FILE: crates/eframe/src/web/events.rs
  function paint_and_schedule (line 21) | pub(crate) fn paint_and_schedule(runner_ref: &WebRunner) -> Result<(), J...
  function paint_if_needed (line 31) | fn paint_if_needed(runner: &mut AppRunner) {
  function install_event_handlers (line 63) | pub(crate) fn install_event_handlers(runner_ref: &WebRunner) -> Result<(...
  function install_blur_focus (line 112) | fn install_blur_focus(runner_ref: &WebRunner, target: &EventTarget) -> R...
  function install_keydown (line 126) | fn install_keydown(runner_ref: &WebRunner, target: &EventTarget) -> Resu...
  function on_keydown (line 167) | pub(crate) fn on_keydown(event: web_sys::KeyboardEvent, runner: &mut App...
  function should_prevent_default_for_key (line 219) | fn should_prevent_default_for_key(
  function install_keyup (line 263) | fn install_keyup(runner_ref: &WebRunner, target: &EventTarget) -> Result...
  function on_keyup (line 268) | pub(crate) fn on_keyup(event: web_sys::KeyboardEvent, runner: &mut AppRu...
  function install_copy_cut_paste (line 317) | fn install_copy_cut_paste(runner_ref: &WebRunner, target: &EventTarget) ...
  function install_window_events (line 400) | fn install_window_events(runner_ref: &WebRunner, window: &EventTarget) -...
  function install_dpr_change_event (line 430) | fn install_dpr_change_event(web_runner: &WebRunner) -> Result<(), JsValu...
  function install_color_scheme_change_event (line 472) | fn install_color_scheme_change_event(
  function prevent_default_and_stop_propagation (line 494) | fn prevent_default_and_stop_propagation(
  function install_pointerdown (line 512) | fn install_pointerdown(runner_ref: &WebRunner, target: &EventTarget) -> ...
  function install_pointerup (line 549) | fn install_pointerup(runner_ref: &WebRunner, target: &EventTarget) -> Re...
  function is_interested_in_pointer_event (line 608) | fn is_interested_in_pointer_event(runner: &AppRunner, pos: egui::Pos2) -...
  function install_mousemove (line 627) | fn install_mousemove(runner_ref: &WebRunner, target: &EventTarget) -> Re...
  function install_mouseleave (line 656) | fn install_mouseleave(runner_ref: &WebRunner, target: &EventTarget) -> R...
  function install_touchstart (line 676) | fn install_touchstart(runner_ref: &WebRunner, target: &EventTarget) -> R...
  function install_touchmove (line 710) | fn install_touchmove(runner_ref: &WebRunner, target: &EventTarget) -> Re...
  function install_touchend (line 738) | fn install_touchend(runner_ref: &WebRunner, target: &EventTarget) -> Res...
  function install_touchcancel (line 788) | fn install_touchcancel(runner_ref: &WebRunner, target: &EventTarget) -> ...
  function install_wheel (line 802) | fn install_wheel(runner_ref: &WebRunner, target: &EventTarget) -> Result...
  function install_gesture (line 849) | fn install_gesture(runner_ref: &WebRunner, target: &EventTarget) -> Resu...
  function handle_gesture (line 866) | fn handle_gesture(event: web_sys::Event, runner: &mut AppRunner) {
  function install_drag_and_drop (line 916) | fn install_drag_and_drop(runner_ref: &WebRunner, target: &EventTarget) -...
  type ResizeObserverContext (line 1022) | pub struct ResizeObserverContext {
    method new (line 1036) | pub fn new(runner_ref: &WebRunner) -> Result<Self, JsValue> {
    method observe (line 1084) | pub fn observe(&self, canvas: &web_sys::HtmlCanvasElement) {
  method drop (line 1030) | fn drop(&mut self) {
  function get_display_size (line 1096) | fn get_display_size(resize_observer_entries: &js_sys::Array) -> Result<(...

FILE: crates/eframe/src/web/input.rs
  function pos_from_mouse_event (line 3) | pub fn pos_from_mouse_event(
  function button_from_mouse_event (line 16) | pub fn button_from_mouse_event(event: &web_sys::MouseEvent) -> Option<eg...
  function primary_touch_pos (line 30) | pub fn primary_touch_pos(
  function pos_from_touch (line 73) | fn pos_from_touch(
  function push_touches (line 85) | pub fn push_touches(runner: &mut AppRunner, phase: egui::TouchPhase, eve...
  function text_from_keyboard_event (line 101) | pub fn text_from_keyboard_event(event: &web_sys::KeyboardEvent) -> Optio...
  function translate_key (line 148) | pub fn translate_key(key: &str) -> Option<egui::Key> {
  function modifiers_from_kb_event (line 152) | pub fn modifiers_from_kb_event(event: &web_sys::KeyboardEvent) -> egui::...
  function modifiers_from_mouse_event (line 168) | pub fn modifiers_from_mouse_event(event: &web_sys::MouseEvent) -> egui::...
  function modifiers_from_wheel_event (line 184) | pub fn modifiers_from_wheel_event(event: &web_sys::WheelEvent) -> egui::...

FILE: crates/eframe/src/web/mod.rs
  constant DEBUG_RESIZE (line 53) | const DEBUG_RESIZE: bool = false;
  function string_from_js_value (line 55) | pub(crate) fn string_from_js_value(value: &JsValue) -> String {
  function focused_element (line 65) | pub(crate) fn focused_element(root: &Node) -> Option<web_sys::Element> {
  function has_focus (line 75) | pub(crate) fn has_focus<T: JsCast>(element: &T) -> bool {
  function now_sec (line 89) | pub fn now_sec() -> f64 {
  function native_pixels_per_point (line 101) | pub fn native_pixels_per_point() -> f32 {
  function system_theme (line 113) | pub fn system_theme() -> Option<egui::Theme> {
  function does_prefer_color_scheme (line 124) | fn does_prefer_color_scheme(window: &web_sys::Window, theme: Theme) -> O...
  function prefers_color_scheme (line 128) | fn prefers_color_scheme(
  function canvas_content_rect (line 140) | fn canvas_content_rect(canvas: &web_sys::HtmlCanvasElement) -> egui::Rect {
  function canvas_size_in_points (line 166) | fn canvas_size_in_points(canvas: &web_sys::HtmlCanvasElement, ctx: &egui...
  function set_cursor_icon (line 180) | fn set_cursor_icon(cursor: egui::CursorIcon) -> Option<()> {
  function set_clipboard_text (line 190) | fn set_clipboard_text(s: &str) {
  function set_clipboard_image (line 211) | fn set_clipboard_image(image: &egui::ColorImage) {
  function to_image (line 254) | fn to_image(image: &egui::ColorImage) -> Result<image::RgbaImage, String> {
  function to_png_bytes (line 264) | fn to_png_bytes(image: &image::RgbaImage) -> Result<Vec<u8>, String> {
  function create_clipboard_item (line 276) | fn create_clipboard_item(mime: &str, bytes: &[u8]) -> Result<web_sys::Cl...
  function cursor_web_name (line 299) | fn cursor_web_name(cursor: egui::CursorIcon) -> &'static str {
  function open_url (line 342) | pub fn open_url(url: &str, new_tab: bool) -> Option<()> {
  function location_hash (line 354) | pub fn location_hash() -> String {
  function percent_decode (line 365) | pub fn percent_decode(s: &str) -> String {
  function is_safari_browser (line 372) | pub fn is_safari_browser() -> bool {

FILE: crates/eframe/src/web/panic_handler.rs
  type PanicHandler (line 12) | pub struct PanicHandler(Arc<Mutex<PanicHandlerInner>>);
    method install (line 16) | pub fn install() -> Self {
    method has_panicked (line 42) | pub fn has_panicked(&self) -> bool {
    method panic_summary (line 47) | pub fn panic_summary(&self) -> Option<PanicSummary> {
  type PanicHandlerInner (line 53) | struct PanicHandlerInner {
  type PanicSummary (line 62) | pub struct PanicSummary {
    method new (line 69) | pub fn new(info: &std::panic::PanicHookInfo<'_>) -> Self {
    method message (line 76) | pub fn message(&self) -> String {
    method callstack (line 81) | pub fn callstack(&self) -> String {
  function error (line 89) | fn error(msg: String);
  function new (line 94) | fn new() -> Error;
  function stack (line 97) | fn stack(error: &Error) -> String;

FILE: crates/eframe/src/web/screen_reader.rs
  function speak (line 2) | pub fn speak(text: &str) {

FILE: crates/eframe/src/web/storage.rs
  function local_storage (line 1) | fn local_storage() -> Option<web_sys::Storage> {
  function local_storage_get (line 6) | pub fn local_storage_get(key: &str) -> Option<String> {
  function local_storage_set (line 11) | pub fn local_storage_set(key: &str, value: &str) {
  function load_memory (line 16) | pub(crate) fn load_memory(ctx: &egui::Context) {
  function load_memory (line 30) | pub(crate) fn load_memory(_: &egui::Context) {}
  function save_memory (line 33) | pub(crate) fn save_memory(ctx: &egui::Context) {
  function save_memory (line 45) | pub(crate) fn save_memory(_: &egui::Context) {}

FILE: crates/eframe/src/web/text_agent.rs
  type TextAgent (line 11) | pub struct TextAgent {
    method attach (line 18) | pub fn attach(runner_ref: &WebRunner, root: Node) -> Result<Self, JsVa...
    method move_to (line 125) | pub fn move_to(
    method set_focus (line 161) | pub fn set_focus(&self, on: bool) {
    method has_focus (line 169) | pub fn has_focus(&self) -> bool {
    method focus (line 173) | pub fn focus(&self) {
    method blur (line 185) | pub fn blur(&self) {
  method drop (line 199) | fn drop(&mut self) {
  function is_mobile_safari (line 205) | fn is_mobile_safari() -> bool {

FILE: crates/eframe/src/web/web_logger.rs
  type WebLogger (line 2) | pub struct WebLogger {
    method init (line 8) | pub fn init(filter: log::LevelFilter) -> Result<(), log::SetLoggerErro...
    method new (line 15) | pub fn new(filter: log::LevelFilter) -> Self {
    method enabled (line 21) | fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
    method log (line 40) | fn log(&self, record: &log::Record<'_>) {
    method flush (line 69) | fn flush(&self) {}
  function trace (line 80) | pub fn trace(s: &str);
  function debug (line 84) | pub fn debug(s: &str);
  function info (line 88) | pub fn info(s: &str);
  function warn (line 92) | pub fn warn(s: &str);
  function shorten_file_path (line 114) | fn shorten_file_path(file_path: &str) -> &str {
  function test_shorten_file_path (line 127) | fn test_shorten_file_path() {

FILE: crates/eframe/src/web/web_painter.rs
  type WebPainter (line 7) | pub(crate) trait WebPainter {
    method canvas (line 14) | fn canvas(&self) -> &web_sys::HtmlCanvasElement;
    method max_texture_side (line 17) | fn max_texture_side(&self) -> usize;
    method paint_and_update_textures (line 22) | fn paint_and_update_textures(
    method handle_screenshots (line 31) | fn handle_screenshots(&mut self, events: &mut Vec<Event>);
    method destroy (line 34) | fn destroy(&mut self);

FILE: crates/eframe/src/web/web_painter_glow.rs
  type WebPainterGlow (line 12) | pub(crate) struct WebPainterGlow {
    method gl (line 19) | pub fn gl(&self) -> &std::sync::Arc<glow::Context> {
    method new (line 23) | pub fn new(
  method max_texture_side (line 46) | fn max_texture_side(&self) -> usize {
  method canvas (line 50) | fn canvas(&self) -> &HtmlCanvasElement {
  method paint_and_update_textures (line 54) | fn paint_and_update_textures(
  method destroy (line 84) | fn destroy(&mut self) {
  method handle_screenshots (line 88) | fn handle_screenshots(&mut self, events: &mut Vec<Event>) {
  function init_glow_context_from_canvas (line 103) | fn init_glow_context_from_canvas(
  function init_webgl1 (line 127) | fn init_webgl1(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'s...
  function init_webgl2 (line 151) | fn init_webgl2(canvas: &HtmlCanvasElement) -> Option<(glow::Context, &'s...
  function webgl1_requires_brightening (line 168) | fn webgl1_requires_brightening(gl: &web_sys::WebGlRenderingContext) -> b...
  function is_safari_and_webkit_gtk (line 187) | fn is_safari_and_webkit_gtk(gl: &web_sys::WebGlRenderingContext) -> bool {

FILE: crates/eframe/src/web/web_painter_wgpu.rs
  type WebPainterWgpu (line 13) | pub(crate) struct WebPainterWgpu {
    method render_state (line 28) | pub fn render_state(&self) -> Option<RenderState> {
    method generate_depth_texture_view (line 32) | pub fn generate_depth_texture_view(
    method new (line 59) | pub async fn new(
  method canvas (line 118) | fn canvas(&self) -> &HtmlCanvasElement {
  method max_texture_side (line 122) | fn max_texture_side(&self) -> usize {
  method paint_and_update_textures (line 128) | fn paint_and_update_textures(
  method handle_screenshots (line 329) | fn handle_screenshots(&mut self, events: &mut Vec<Event>) {
  method destroy (line 342) | fn destroy(&mut self) {

FILE: crates/eframe/src/web/web_runner.rs
  type WebRunner (line 19) | pub struct WebRunner {
    method new (line 41) | pub fn new() -> Self {
    method start (line 57) | pub async fn start(
    method has_panicked (line 99) | pub fn has_panicked(&self) -> bool {
    method panic_summary (line 104) | pub fn panic_summary(&self) -> Option<super::PanicSummary> {
    method unsubscribe_from_all_events (line 108) | fn unsubscribe_from_all_events(&self) {
    method destroy (line 128) | pub fn destroy(&self) {
    method try_lock (line 143) | pub(crate) fn try_lock(&self) -> Option<std::cell::RefMut<'_, AppRunne...
    method app_mut (line 160) | pub fn app_mut<ConcreteApp: 'static + App>(
    method add_event_listener (line 172) | pub fn add_event_listener<E: wasm_bindgen::JsCast>(
    method add_event_listener_ex (line 192) | pub fn add_event_listener_ex<E: wasm_bindgen::JsCast>(
    method request_animation_frame (line 237) | pub(crate) fn request_animation_frame(&self) -> Result<(), wasm_bindge...
  type AnimationFrameRequest (line 268) | struct AnimationFrameRequest {
  type TargetEvent (line 277) | struct TargetEvent {
  type IntervalHandle (line 284) | struct IntervalHandle {
  type EventToUnsubscribe (line 289) | enum EventToUnsubscribe {
    method unsubscribe (line 297) | pub fn unsubscribe(self) -> Result<(), JsValue> {

FILE: crates/egui-wgpu/src/capture.rs
  type CaptureState (line 14) | pub struct CaptureState {
    method new (line 26) | pub fn new(device: &wgpu::Device, surface_texture: &wgpu::Texture) -> ...
    method create_texture (line 67) | fn create_texture(
    method update (line 102) | pub fn update(&mut self, device: &wgpu::Device, texture: &wgpu::Textur...
    method copy_textures (line 114) | pub fn copy_textures(
    method read_screen_rgba (line 182) | pub fn read_screen_rgba(
  type CaptureReceiver (line 21) | pub type CaptureReceiver = mpsc::Receiver<(ViewportId, Vec<UserData>, Co...
  type CaptureSender (line 22) | pub type CaptureSender = mpsc::Sender<(ViewportId, Vec<UserData>, ColorI...
  type BufferPadding (line 246) | struct BufferPadding {
    method new (line 252) | fn new(width: u32) -> Self {

FILE: crates/egui-wgpu/src/lib.rs
  type WgpuError (line 43) | pub enum WgpuError {
  type RenderState (line 66) | pub struct RenderState {
    method create (line 171) | pub async fn create(
  function request_adapter (line 90) | async fn request_adapter(
  function describe_adapters (line 261) | fn describe_adapters(adapters: &[wgpu::Adapter]) -> String {
  type SurfaceErrorAction (line 276) | pub enum SurfaceErrorAction {
  type WgpuConfiguration (line 286) | pub struct WgpuConfiguration {
    method fmt (line 313) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function wgpu_config_impl_send_sync (line 307) | fn wgpu_config_impl_send_sync() {
  method default (line 332) | fn default() -> Self {
  function preferred_framebuffer_format (line 355) | pub fn preferred_framebuffer_format(
  function depth_format_from_bits (line 374) | pub fn depth_format_from_bits(depth_buffer: u8, stencil_buffer: u8) -> O...
  function adapter_info_summary (line 389) | pub fn adapter_info_summary(info: &wgpu::AdapterInfo) -> String {
  function parse_vendor_id (line 446) | pub fn parse_vendor_id(vendor_id: u32) -> &'static str {

FILE: crates/egui-wgpu/src/renderer.rs
  type CallbackResources (line 17) | pub type CallbackResources = type_map::concurrent::TypeMap;
  type CallbackResources (line 23) | pub type CallbackResources = type_map::TypeMap;
  type Callback (line 30) | pub struct Callback(Box<dyn CallbackTrait>);
    method new_paint_callback (line 34) | pub fn new_paint_callback(
  type CallbackTrait (line 89) | pub trait CallbackTrait: Send + Sync {
    method prepare (line 90) | fn prepare(
    method finish_prepare (line 102) | fn finish_prepare(
    method paint (line 116) | fn paint(
  type ScreenDescriptor (line 125) | pub struct ScreenDescriptor {
    method screen_size_in_points (line 135) | fn screen_size_in_points(&self) -> [f32; 2] {
  type UniformBuffer (line 146) | struct UniformBuffer {
  type SlicedBuffer (line 156) | struct SlicedBuffer {
  type Texture (line 162) | pub struct Texture {
  type RendererOptions (line 176) | pub struct RendererOptions {
    constant PREDICTABLE (line 218) | pub const PREDICTABLE: Self = Self {
  method default (line 227) | fn default() -> Self {
  type Renderer (line 238) | pub struct Renderer {
    method new (line 269) | pub fn new(
    method render (line 472) | pub fn render(
    method update_texture (line 595) | pub fn update_texture(
    method free_texture (line 730) | pub fn free_texture(&mut self, id: &epaint::TextureId) {
    method texture (line 740) | pub fn texture(&self, id: &epaint::TextureId) -> Option<&Texture> {
    method register_native_texture (line 749) | pub fn register_native_texture(
    method update_egui_texture_from_wgpu_texture (line 770) | pub fn update_egui_texture_from_wgpu_texture(
    method register_native_texture_with_sampler_options (line 799) | pub fn register_native_texture_with_sampler_options(
    method update_egui_texture_from_wgpu_texture_with_sampler_options (line 846) | pub fn update_egui_texture_from_wgpu_texture_with_sampler_options(
    method update_buffers (line 890) | pub fn update_buffers(
  function create_sampler (line 1053) | fn create_sampler(
  function create_vertex_buffer (line 1082) | fn create_vertex_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
  function create_index_buffer (line 1092) | fn create_index_buffer(device: &wgpu::Device, size: u64) -> wgpu::Buffer {
  type ScissorRect (line 1103) | struct ScissorRect {
    method new (line 1111) | fn new(clip_rect: &epaint::Rect, pixels_per_point: f32, target_size: [...
  function renderer_impl_send_sync (line 1145) | fn renderer_impl_send_sync() {

FILE: crates/egui-wgpu/src/setup.rs
  type WgpuSetup (line 4) | pub enum WgpuSetup {
    method fmt (line 32) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new_instance (line 48) | pub async fn new_instance(&self) -> wgpu::Instance {
    method from (line 77) | fn from(create_new: WgpuSetupCreateNew) -> Self {
    method from (line 83) | fn from(existing: WgpuSetupExisting) -> Self {
  method default (line 26) | fn default() -> Self {
  type NativeAdapterSelectorMethod (line 92) | pub type NativeAdapterSelectorMethod = Arc<
  type WgpuSetupCreateNew (line 101) | pub struct WgpuSetupCreateNew {
    method fmt (line 143) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 132) | fn clone(&self) -> Self {
  method default (line 156) | fn default() -> Self {
  type WgpuSetupExisting (line 199) | pub struct WgpuSetupExisting {

FILE: crates/egui-wgpu/src/winit.rs
  type SurfaceState (line 14) | struct SurfaceState {
  type Painter (line 27) | pub struct Painter {
    method new (line 58) | pub async fn new(
    method render_state (line 89) | pub fn render_state(&self) -> Option<RenderState> {
    method configure_surface (line 93) | fn configure_surface(
    method set_window (line 145) | pub async fn set_window(
    method set_window_unsafe (line 171) | pub async unsafe fn set_window_unsafe(
    method add_surface (line 194) | async fn add_surface(
    method max_texture_side (line 256) | pub fn max_texture_side(&self) -> Option<usize> {
    method resize_and_generate_depth_texture_view_and_msaa_view (line 262) | fn resize_and_generate_depth_texture_view_and_msaa_view(
    method on_window_resize_state_change (line 337) | pub fn on_window_resize_state_change(&mut self, viewport_id: ViewportI...
    method on_window_resized (line 385) | pub fn on_window_resized(
    method paint_and_update_textures (line 412) | pub fn paint_and_update_textures(
    method handle_screenshots (line 658) | pub fn handle_screenshots(&self, events: &mut Vec<Event>) {
    method gc_viewports (line 671) | pub fn gc_viewports(&mut self, active_viewports: &ViewportIdSet) {
    method destroy (line 680) | pub fn destroy(&mut self) {

FILE: crates/egui-winit/src/clipboard.rs
  type Clipboard (line 7) | pub struct Clipboard {
    method new (line 32) | pub fn new(_raw_display_handle: Option<RawDisplayHandle>) -> Self {
    method get (line 56) | pub fn get(&mut self) -> Option<String> {
    method set_text (line 94) | pub fn set_text(&mut self, text: String) {
    method set_image (line 124) | pub fn set_image(&mut self, image: &egui::ColorImage) {
  function init_arboard (line 152) | fn init_arboard() -> Option<arboard::Clipboard> {
  function init_smithay_clipboard (line 175) | fn init_smithay_clipboard(

FILE: crates/egui-winit/src/lib.rs
  function screen_size_in_pixels (line 35) | pub fn screen_size_in_pixels(window: &Window) -> egui::Vec2 {
  function pixels_per_point (line 48) | pub fn pixels_per_point(egui_ctx: &egui::Context, window: &Window) -> f32 {
  type EventResponse (line 58) | pub struct EventResponse {
  type State (line 77) | pub struct State {
    method new (line 113) | pub fn new(
    method init_accesskit (line 167) | pub fn init_accesskit<T: From<accesskit_winit::Event> + Send>(
    method set_max_texture_side (line 184) | pub fn set_max_texture_side(&mut self, max_texture_side: usize) {
    method clipboard_text (line 189) | pub fn clipboard_text(&mut self) -> Option<String> {
    method set_clipboard_text (line 194) | pub fn set_clipboard_text(&mut self, text: String) {
    method allow_ime (line 199) | pub fn allow_ime(&self) -> bool {
    method set_allow_ime (line 204) | pub fn set_allow_ime(&mut self, allow: bool) {
    method egui_ctx (line 209) | pub fn egui_ctx(&self) -> &egui::Context {
    method egui_input (line 216) | pub fn egui_input(&self) -> &egui::RawInput {
    method egui_input_mut (line 223) | pub fn egui_input_mut(&mut self) -> &mut egui::RawInput {
    method take_egui_input (line 234) | pub fn take_egui_input(&mut self, window: &Window) -> egui::RawInput {
    method on_window_event (line 265) | pub fn on_window_event(
    method on_ime (line 569) | fn on_ime(&mut self, ime: &winit::event::Ime) {
    method ime_event_enable (line 638) | pub fn ime_event_enable(&mut self) {
    method ime_event_disable (line 647) | pub fn ime_event_disable(&mut self) {
    method on_mouse_motion (line 655) | pub fn on_mouse_motion(&mut self, delta: (f64, f64)) -> bool {
    method is_pointer_in_window (line 668) | pub fn is_pointer_in_window(&self) -> bool {
    method is_any_pointer_button_down (line 673) | pub fn is_any_pointer_button_down(&self) -> bool {
    method on_accesskit_action_request (line 681) | pub fn on_accesskit_action_request(&mut self, request: accesskit::Acti...
    method on_mouse_button_input (line 687) | fn on_mouse_button_input(
    method on_cursor_moved (line 732) | fn on_cursor_moved(
    method on_touch (line 766) | fn on_touch(&mut self, window: &Window, touch: &winit::event::Touch) {
    method on_mouse_wheel (line 826) | fn on_mouse_wheel(
    method on_keyboard_input (line 858) | fn on_keyboard_input(&mut self, event: &winit::event::KeyEvent) {
    method handle_platform_output (line 967) | pub fn handle_platform_output(
    method set_cursor_icon (line 1043) | fn set_cursor_icon(&mut self, window: &Window, cursor_icon: egui::Curs...
  function to_egui_touch_phase (line 1067) | fn to_egui_touch_phase(phase: winit::event::TouchPhase) -> egui::TouchPh...
  function to_egui_theme (line 1076) | fn to_egui_theme(theme: winit::window::Theme) -> Theme {
  function inner_rect_in_points (line 1083) | pub fn inner_rect_in_points(window: &Window, pixels_per_point: f32) -> O...
  function outer_rect_in_points (line 1095) | pub fn outer_rect_in_points(window: &Window, pixels_per_point: f32) -> O...
  function update_viewport_info (line 1112) | pub fn update_viewport_info(
  function open_url_in_browser (line 1167) | fn open_url_in_browser(_url: &str) {
  function is_printable_char (line 1183) | fn is_printable_char(chr: char) -> bool {
  function is_cut_command (line 1191) | fn is_cut_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bool {
  function is_copy_command (line 1197) | fn is_copy_command(modifiers: egui::Modifiers, keycode: egui::Key) -> bo...
  function is_paste_command (line 1203) | fn is_paste_command(modifiers: egui::Modifiers, keycode: egui::Key) -> b...
  function translate_mouse_button (line 1209) | fn translate_mouse_button(button: winit::event::MouseButton) -> Option<e...
  function key_from_winit_key (line 1220) | fn key_from_winit_key(key: &winit::keyboard::Key) -> Option<egui::Key> {
  function key_from_named_key (line 1228) | fn key_from_named_key(named_key: winit::keyboard::NamedKey) -> Option<eg...
  function key_from_key_code (line 1297) | fn key_from_key_code(key: winit::keyboard::KeyCode) -> Option<egui::Key> {
  function translate_cursor (line 1419) | fn translate_cursor(cursor_icon: egui::CursorIcon) -> Option<winit::wind...
  type ActionRequested (line 1466) | pub enum ActionRequested {
  function process_viewport_commands (line 1473) | pub fn process_viewport_commands(
  function process_viewport_command (line 1485) | fn process_viewport_command(
  function create_window (line 1703) | pub fn create_window(
  function create_winit_window_attributes (line 1716) | pub fn create_winit_window_attributes(
  function to_winit_icon (line 1909) | fn to_winit_icon(icon: &egui::IconData) -> Option<winit::window::Icon> {
  function apply_viewport_builder_to_window (line 1925) | pub fn apply_viewport_builder_to_window(
  function short_device_event_description (line 1980) | pub fn short_device_event_description(event: &winit::event::DeviceEvent)...
  function short_window_event_description (line 1996) | pub fn short_window_event_description(event: &winit::event::WindowEvent)...

FILE: crates/egui-winit/src/safe_area.rs
  function get_safe_area_insets (line 20) | pub fn get_safe_area_insets() -> SafeAreaInsets {

FILE: crates/egui-winit/src/window_settings.rs
  type WindowSettings (line 7) | pub struct WindowSettings {
    method from_window (line 23) | pub fn from_window(egui_zoom_factor: f32, window: &winit::window::Wind...
    method inner_size_points (line 52) | pub fn inner_size_points(&self) -> Option<egui::Vec2> {
    method initialize_viewport_builder (line 56) | pub fn initialize_viewport_builder(
    method initialize_window (line 93) | pub fn initialize_window(&self, window: &winit::window::Window) {
    method clamp_size_to_sane_values (line 103) | pub fn clamp_size_to_sane_values(&mut self, largest_monitor_size_point...
    method clamp_position_to_monitors (line 117) | pub fn clamp_position_to_monitors(
  function find_active_monitor (line 144) | fn find_active_monitor(
  function clamp_pos_to_monitors (line 178) | fn clamp_pos_to_monitors(

FILE: crates/egui/src/animation_manager.rs
  type AnimationManager (line 7) | pub(crate) struct AnimationManager {
    method animate_bool (line 30) | pub fn animate_bool(
    method animate_value (line 68) | pub fn animate_value(
  type BoolAnim (line 13) | struct BoolAnim {
  type ValueAnim (line 19) | struct ValueAnim {

FILE: crates/egui/src/atomics/atom.rs
  type Atom (line 16) | pub struct Atom<'a> {
  method default (line 40) | fn default() -> Self {
  function grow (line 58) | pub fn grow() -> Self {
  function custom (line 81) | pub fn custom(id: Id, size: impl Into<Vec2>) -> Self {
  function into_sized (line 91) | pub fn into_sized(
  function from (line 143) | fn from(value: T) -> Self {

FILE: crates/egui/src/atomics/atom_ext.rs
  type AtomExt (line 7) | pub trait AtomExt<'a> {
    method atom_id (line 12) | fn atom_id(self, id: Id) -> Atom<'a>;
    method atom_size (line 23) | fn atom_size(self, size: Vec2) -> Atom<'a>;
    method atom_grow (line 32) | fn atom_grow(self, grow: bool) -> Atom<'a>;
    method atom_shrink (line 43) | fn atom_shrink(self, shrink: bool) -> Atom<'a>;
    method atom_max_size (line 49) | fn atom_max_size(self, max_size: Vec2) -> Atom<'a>;
    method atom_max_width (line 55) | fn atom_max_width(self, max_width: f32) -> Atom<'a>;
    method atom_max_height (line 58) | fn atom_max_height(self, max_height: f32) -> Atom<'a>;
    method atom_max_height_font_size (line 63) | fn atom_max_height_font_size(self, ui: &Ui) -> Atom<'a>
    method atom_align (line 76) | fn atom_align(self, align: emath::Align2) -> Atom<'a>;
  method atom_id (line 83) | fn atom_id(self, id: Id) -> Atom<'a> {
  method atom_size (line 89) | fn atom_size(self, size: Vec2) -> Atom<'a> {
  method atom_grow (line 95) | fn atom_grow(self, grow: bool) -> Atom<'a> {
  method atom_shrink (line 101) | fn atom_shrink(self, shrink: bool) -> Atom<'a> {
  method atom_max_size (line 107) | fn atom_max_size(self, max_size: Vec2) -> Atom<'a> {
  method atom_max_width (line 113) | fn atom_max_width(self, max_width: f32) -> Atom<'a> {
  method atom_max_height (line 119) | fn atom_max_height(self, max_height: f32) -> Atom<'a> {
  method atom_align (line 125) | fn atom_align(self, align: emath::Align2) -> Atom<'a> {

FILE: crates/egui/src/atomics/atom_kind.rs
  type IntoSizedArgs (line 7) | pub struct IntoSizedArgs {
  type IntoSizedResult (line 14) | pub struct IntoSizedResult<'a> {
  type AtomClosure (line 22) | pub type AtomClosure<'a> = Box<dyn FnOnce(&Ui, IntoSizedArgs) -> IntoSiz...
  type AtomKind (line 26) | pub enum AtomKind<'a> {
  method clone (line 71) | fn clone(&self) -> Self {
  method fmt (line 85) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function text (line 97) | pub fn text(text: impl Into<WidgetText>) -> Self {
  function image (line 102) | pub fn image(image: impl Into<Image<'a>>) -> Self {
  function closure (line 107) | pub fn closure(func: impl FnOnce(&Ui, IntoSizedArgs) -> IntoSizedResult<...
  function into_sized (line 115) | pub fn into_sized(
  function from (line 157) | fn from(value: ImageSource<'a>) -> Self {
  function from (line 163) | fn from(value: Image<'a>) -> Self {
  function from (line 172) | fn from(value: T) -> Self {

FILE: crates/egui/src/atomics/atom_layout.rs
  type AtomLayout (line 32) | pub struct AtomLayout<'a> {
  method default (line 47) | fn default() -> Self {
  function new (line 53) | pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
  function gap (line 73) | pub fn gap(mut self, gap: f32) -> Self {
  function frame (line 80) | pub fn frame(mut self, frame: Frame) -> Self {
  function sense (line 87) | pub fn sense(mut self, sense: Sense) -> Self {
  function fallback_text_color (line 96) | pub fn fallback_text_color(mut self, color: Color32) -> Self {
  function fallback_font (line 103) | pub fn fallback_font(mut self, font: impl Into<FontSelection>) -> Self {
  function min_size (line 113) | pub fn min_size(mut self, size: Vec2) -> Self {
  function max_size (line 122) | pub fn max_size(mut self, size: Vec2) -> Self {
  function max_width (line 131) | pub fn max_width(mut self, width: f32) -> Self {
  function max_height (line 140) | pub fn max_height(mut self, height: f32) -> Self {
  function id (line 147) | pub fn id(mut self, id: Id) -> Self {
  function wrap_mode (line 158) | pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
  function align2 (line 171) | pub fn align2(mut self, align2: Align2) -> Self {
  function show (line 177) | pub fn show(self, ui: &mut Ui) -> AtomLayoutResponse {
  function allocate (line 184) | pub fn allocate(self, ui: &mut Ui) -> AllocatedAtomLayout<'a> {
  type AllocatedAtomLayout (line 339) | pub struct AllocatedAtomLayout<'a> {
  function iter_kinds (line 352) | pub fn iter_kinds(&self) -> impl Iterator<Item = &SizedAtomKind<'atom>> {
  function iter_kinds_mut (line 356) | pub fn iter_kinds_mut(&mut self) -> impl Iterator<Item = &mut SizedAtomK...
  function iter_images (line 360) | pub fn iter_images(&self) -> impl Iterator<Item = &Image<'atom>> {
  function iter_images_mut (line 370) | pub fn iter_images_mut(&mut self) -> impl Iterator<Item = &mut Image<'at...
  function iter_texts (line 380) | pub fn iter_texts(&self) -> impl Iterator<Item = &Arc<Galley>> + use<'at...
  function iter_texts_mut (line 390) | pub fn iter_texts_mut(&mut self) -> impl Iterator<Item = &mut Arc<Galley...
  function map_kind (line 400) | pub fn map_kind<F>(&mut self, mut f: F)
  function map_images (line 409) | pub fn map_images<F>(&mut self, mut f: F)
  function paint (line 426) | pub fn paint(self, ui: &Ui) -> AtomLayoutResponse {
  type AtomLayoutResponse (line 495) | pub struct AtomLayoutResponse {
    method empty (line 502) | pub fn empty(response: Response) -> Self {
    method custom_rects (line 509) | pub fn custom_rects(&self) -> impl Iterator<Item = (Id, Rect)> + '_ {
    method rect (line 516) | pub fn rect(&self, id: Id) -> Option<Rect> {
  method ui (line 524) | fn ui(self, ui: &mut Ui) -> Response {
  type Target (line 530) | type Target = Atoms<'a>;
  method deref (line 532) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 538) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Target (line 544) | type Target = [SizedAtom<'a>];
  method deref (line 546) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 552) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: crates/egui/src/atomics/atoms.rs
  constant ATOMS_SMALL_VEC_SIZE (line 8) | pub(crate) const ATOMS_SMALL_VEC_SIZE: usize = 2;
  type Atoms (line 12) | pub struct Atoms<'a>(SmallVec<[Atom<'a>; ATOMS_SMALL_VEC_SIZE]>);
  function new (line 15) | pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
  function push_right (line 20) | pub fn push_right(&mut self, atom: impl Into<Atom<'a>>) {
  function extend_right (line 27) | pub fn extend_right(&mut self, atoms: Self) {
  function push_left (line 32) | pub fn push_left(&mut self, atom: impl Into<Atom<'a>>) {
  function extend_left (line 39) | pub fn extend_left(&mut self, mut atoms: Self) {
  function text (line 47) | pub fn text(&self) -> Option<Cow<'_, str>> {
  function iter_kinds (line 72) | pub fn iter_kinds(&self) -> impl Iterator<Item = &AtomKind<'a>> {
  function iter_kinds_mut (line 76) | pub fn iter_kinds_mut(&mut self) -> impl Iterator<Item = &mut AtomKind<'...
  function iter_images (line 80) | pub fn iter_images(&self) -> impl Iterator<Item = &Image<'a>> {
  function iter_images_mut (line 90) | pub fn iter_images_mut(&mut self) -> impl Iterator<Item = &mut Image<'a>> {
  function iter_texts (line 100) | pub fn iter_texts(&self) -> impl Iterator<Item = &WidgetText> + use<'_, ...
  function iter_texts_mut (line 110) | pub fn iter_texts_mut(&mut self) -> impl Iterator<Item = &mut WidgetText...
  function map_atoms (line 120) | pub fn map_atoms(&mut self, mut f: impl FnMut(Atom<'a>) -> Atom<'a>) {
  function map_kind (line 125) | pub fn map_kind<F>(&mut self, mut f: F)
  function map_images (line 134) | pub fn map_images<F>(&mut self, mut f: F)
  function map_texts (line 147) | pub fn map_texts<F>(&mut self, mut f: F)
  type Item (line 162) | type Item = Atom<'a>;
  type IntoIter (line 163) | type IntoIter = smallvec::IntoIter<[Atom<'a>; ATOMS_SMALL_VEC_SIZE]>;
  method into_iter (line 165) | fn into_iter(self) -> Self::IntoIter {
  method collect (line 184) | fn collect(self, atoms: &mut Atoms<'a>) {
  type IntoAtoms (line 190) | pub trait IntoAtoms<'a> {
    method collect (line 191) | fn collect(self, atoms: &mut Atoms<'a>);
    method into_atoms (line 193) | fn into_atoms(self) -> Atoms<'a>
  function collect (line 204) | fn collect(self, atoms: &mut Self) {
  type Target (line 232) | type Target = [Atom<'a>];
  method deref (line 234) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 240) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 246) | fn from(vec: Vec<T>) -> Self {
  function from (line 252) | fn from(slice: &[T]) -> Self {
  function from_iter (line 258) | fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self {
  function collect_atoms (line 268) | fn collect_atoms() {

FILE: crates/egui/src/atomics/sized_atom.rs
  type SizedAtom (line 6) | pub struct SizedAtom<'a> {
  function is_grow (line 28) | pub fn is_grow(&self) -> bool {

FILE: crates/egui/src/atomics/sized_atom_kind.rs
  type SizedAtomKind (line 8) | pub enum SizedAtomKind<'a> {
  method default (line 15) | fn default() -> Self {
  function size (line 22) | pub fn size(&self) -> Vec2 {

FILE: crates/egui/src/cache/cache_storage.rs
  type CacheStorage (line 25) | pub struct CacheStorage {
    method cache (line 30) | pub fn cache<Cache: CacheTrait + Default>(&mut self) -> &mut Cache {
    method num_values (line 43) | fn num_values(&self) -> usize {
    method update (line 48) | pub fn update(&mut self) {
    method fmt (line 64) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 57) | fn clone(&self) -> Self {

FILE: crates/egui/src/cache/cache_trait.rs
  type CacheTrait (line 3) | pub trait CacheTrait: 'static + Send + Sync + std::any::Any {
    method update (line 5) | fn update(&mut self);
    method len (line 8) | fn len(&self) -> usize;

FILE: crates/egui/src/cache/frame_cache.rs
  type ComputerMut (line 5) | pub trait ComputerMut<Key, Value>: 'static + Send + Sync {
    method compute (line 6) | fn compute(&mut self, key: Key) -> Value;
  type FrameCache (line 12) | pub struct FrameCache<Value, Computer> {
  method default (line 22) | fn default() -> Self {
  function new (line 28) | pub fn new(computer: Computer) -> Self {
  function evict_cache (line 37) | pub fn evict_cache(&mut self) {
  function get (line 49) | pub fn get<Key>(&mut self, key: Key) -> &Value
  method update (line 74) | fn update(&mut self) {
  method len (line 78) | fn len(&self) -> usize {

FILE: crates/egui/src/cache/frame_publisher.rs
  type FramePublisher (line 6) | pub struct FramePublisher<Key: Eq + Hash, Value> {
  method default (line 12) | fn default() -> Self {
  function new (line 18) | pub fn new() -> Self {
  function set (line 26) | pub fn set(&mut self, key: Key, value: Value) {
  function get (line 31) | pub fn get(&self, key: &Key) -> Option<&Value> {
  function evict_cache (line 36) | pub fn evict_cache(&mut self) {
  method update (line 50) | fn update(&mut self) {
  method len (line 54) | fn len(&self) -> usize {

FILE: crates/egui/src/callstack.rs
  type Frame (line 2) | struct Frame {
  function capture (line 14) | pub fn capture() -> String {
  function clean_symbol_name (line 147) | fn clean_symbol_name(mut s: String) -> String {
  function test_clean_symbol_name (line 162) | fn test_clean_symbol_name() {
  function shorten_source_file_path (line 175) | fn shorten_source_file_path(path: &std::path::Path) -> String {
  function test_shorten_path (line 205) | fn test_shorten_path() {

FILE: crates/egui/src/containers/area.rs
  type AreaState (line 18) | pub struct AreaState {
    method load (line 58) | pub fn load(ctx: &Context, id: Id) -> Option<Self> {
    method left_top_pos (line 64) | pub fn left_top_pos(&self) -> Pos2 {
    method set_left_top_pos (line 75) | pub fn set_left_top_pos(&mut self, pos: Pos2) {
    method rect (line 84) | pub fn rect(&self) -> Rect {
  method default (line 45) | fn default() -> Self {
  type Area (line 107) | pub struct Area {
    method new (line 133) | pub fn new(id: Id) -> Self {
    method id (line 159) | pub fn id(mut self, id: Id) -> Self {
    method kind (line 168) | pub fn kind(mut self, kind: UiKind) -> Self {
    method info (line 177) | pub fn info(mut self, info: UiStackInfo) -> Self {
    method layer (line 182) | pub fn layer(&self) -> LayerId {
    method enabled (line 191) | pub fn enabled(mut self, enabled: bool) -> Self {
    method movable (line 198) | pub fn movable(mut self, movable: bool) -> Self {
    method is_enabled (line 204) | pub fn is_enabled(&self) -> bool {
    method is_movable (line 208) | pub fn is_movable(&self) -> bool {
    method interactable (line 218) | pub fn interactable(mut self, interactable: bool) -> Self {
    method sense (line 228) | pub fn sense(mut self, sense: Sense) -> Self {
    method order (line 235) | pub fn order(mut self, order: Order) -> Self {
    method default_pos (line 241) | pub fn default_pos(mut self, default_pos: impl Into<Pos2>) -> Self {
    method default_size (line 256) | pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
    method default_width (line 263) | pub fn default_width(mut self, default_width: f32) -> Self {
    method default_height (line 270) | pub fn default_height(mut self, default_height: f32) -> Self {
    method fixed_pos (line 277) | pub fn fixed_pos(mut self, fixed_pos: impl Into<Pos2>) -> Self {
    method constrain (line 287) | pub fn constrain(mut self, constrain: bool) -> Self {
    method constrain_to (line 296) | pub fn constrain_to(mut self, constrain_rect: Rect) -> Self {
    method pivot (line 310) | pub fn pivot(mut self, pivot: Align2) -> Self {
    method current_pos (line 317) | pub fn current_pos(mut self, current_pos: impl Into<Pos2>) -> Self {
    method anchor (line 334) | pub fn anchor(mut self, align: Align2, offset: impl Into<Vec2>) -> Self {
    method get_pivot (line 339) | pub(crate) fn get_pivot(&self) -> Align2 {
    method fade_in (line 351) | pub fn fade_in(mut self, fade_in: bool) -> Self {
    method layout (line 358) | pub fn layout(mut self, layout: Layout) -> Self {
    method sizing_pass (line 379) | pub fn sizing_pass(mut self, resize: bool) -> Self {
    method show (line 406) | pub fn show<R>(
    method begin (line 418) | pub(crate) fn begin(self, ctx: &Context) -> Prepared {
  type State (line 128) | type State = AreaState;
  type Prepared (line 385) | pub(crate) struct Prepared {
    method state (line 596) | pub(crate) fn state(&self) -> &AreaState {
    method state_mut (line 600) | pub(crate) fn state_mut(&mut self) -> &mut AreaState {
    method constrain (line 604) | pub(crate) fn constrain(&self) -> bool {
    method constrain_rect (line 608) | pub(crate) fn constrain_rect(&self) -> Rect {
    method content_ui (line 612) | pub(crate) fn content_ui(&mut self, ctx: &Context) -> Ui {
    method with_widget_info (line 650) | pub(crate) fn with_widget_info(&self, make_info: impl Fn() -> crate::W...
    method id (line 654) | pub(crate) fn id(&self) -> Id {
    method end (line 659) | pub(crate) fn end(self, ctx: &Context, content_ui: Ui) -> Response {
  function round_area_position (line 585) | fn round_area_position(ctx: &Context, pos: Pos2) -> Pos2 {
  function pointer_pressed_on_area (line 694) | fn pointer_pressed_on_area(ctx: &Context, layer_id: LayerId) -> bool {
  function automatic_area_position (line 703) | fn automatic_area_position(ctx: &Context, constrain_rect: Rect, layer_id...

FILE: crates/egui/src/containers/close_tag.rs
  type ClosableTag (line 12) | pub struct ClosableTag {
    constant NAME (line 17) | pub const NAME: &'static str = "egui_close_tag";
    method set_close (line 20) | pub fn set_close(&self) {
    method should_close (line 25) | pub fn should_close(&self) -> bool {

FILE: crates/egui/src/containers/collapsing_header.rs
  type InnerState (line 13) | pub(crate) struct InnerState {
  type CollapsingState (line 27) | pub struct CollapsingState {
    method load (line 33) | pub fn load(ctx: &Context, id: Id) -> Option<Self> {
    method store (line 40) | pub fn store(&self, ctx: &Context) {
    method remove (line 44) | pub fn remove(&self, ctx: &Context) {
    method id (line 48) | pub fn id(&self) -> Id {
    method load_with_default_open (line 52) | pub fn load_with_default_open(ctx: &Context, id: Id, default_open: boo...
    method is_open (line 62) | pub fn is_open(&self) -> bool {
    method set_open (line 66) | pub fn set_open(&mut self, open: bool) {
    method toggle (line 70) | pub fn toggle(&mut self, ui: &Ui) {
    method openness (line 76) | pub fn openness(&self, ctx: &Context) -> f32 {
    method show_default_button_with_size (line 85) | pub(crate) fn show_default_button_with_size(
    method show_default_button_indented (line 109) | fn show_default_button_indented(&mut self, ui: &mut Ui) -> Response {
    method show_button_indented (line 114) | fn show_button_indented(
    method show_header (line 155) | pub fn show_header<HeaderRet>(
    method show_body_indented (line 182) | pub fn show_body_indented<R>(
    method show_body_unindented (line 201) | pub fn show_body_unindented<R>(
    method show_toggle_button (line 280) | pub fn show_toggle_button(
  type HeaderResponse (line 291) | pub struct HeaderResponse<'ui, HeaderRet> {
  function is_open (line 299) | pub fn is_open(&self) -> bool {
  function set_open (line 303) | pub fn set_open(&mut self, open: bool) {
  function toggle (line 307) | pub fn toggle(&mut self) {
  function body (line 312) | pub fn body<BodyRet>(
  function body_unindented (line 331) | pub fn body_unindented<BodyRet>(
  function paint_default_icon (line 351) | pub fn paint_default_icon(ui: &mut Ui, openness: f32, response: &Respons...
  type IconPainter (line 374) | pub type IconPainter = Box<dyn FnOnce(&mut Ui, f32, &Response)>;
  type CollapsingHeader (line 392) | pub struct CollapsingHeader {
    method new (line 411) | pub fn new(text: impl Into<WidgetText>) -> Self {
    method default_open (line 430) | pub fn default_open(mut self, open: bool) -> Self {
    method open (line 441) | pub fn open(mut self, open: Option<bool>) -> Self {
    method id_salt (line 449) | pub fn id_salt(mut self, id_salt: impl Hash) -> Self {
    method id_source (line 458) | pub fn id_source(mut self, id_salt: impl Hash) -> Self {
    method enabled (line 467) | pub fn enabled(mut self, enabled: bool) -> Self {
    method show_background (line 481) | pub fn show_background(mut self, show_background: bool) -> Self {
    method icon (line 504) | pub fn icon(mut self, icon_fn: impl FnOnce(&mut Ui, f32, &Response) + ...
    method begin (line 517) | fn begin(self, ui: &mut Ui) -> Prepared {
    method show (line 633) | pub fn show<R>(
    method show_unindented (line 642) | pub fn show_unindented<R>(
    method show_dyn (line 650) | fn show_dyn<'c, R>(
  type Prepared (line 510) | struct Prepared {
  type CollapsingResponse (line 696) | pub struct CollapsingResponse<R> {
  function fully_closed (line 712) | pub fn fully_closed(&self) -> bool {
  function fully_open (line 717) | pub fn fully_open(&self) -> bool {

FILE: crates/egui/src/containers/combo_box.rs
  type IconPainter (line 13) | pub type IconPainter = Box<dyn FnOnce(&Ui, Rect, &WidgetVisuals, bool)>;
  type ComboBox (line 38) | pub struct ComboBox {
    method new (line 52) | pub fn new(id_salt: impl std::hash::Hash, label: impl Into<WidgetText>...
    method from_label (line 67) | pub fn from_label(label: impl Into<WidgetText>) -> Self {
    method from_id_salt (line 83) | pub fn from_id_salt(id_salt: impl std::hash::Hash) -> Self {
    method from_id_source (line 99) | pub fn from_id_source(id_salt: impl std::hash::Hash) -> Self {
    method width (line 107) | pub fn width(mut self, width: f32) -> Self {
    method height (line 116) | pub fn height(mut self, height: f32) -> Self {
    method selected_text (line 123) | pub fn selected_text(mut self, selected_text: impl Into<WidgetText>) -...
    method icon (line 159) | pub fn icon(mut self, icon_fn: impl FnOnce(&Ui, Rect, &WidgetVisuals, ...
    method wrap_mode (line 170) | pub fn wrap_mode(mut self, wrap_mode: TextWrapMode) -> Self {
    method wrap (line 177) | pub fn wrap(mut self) -> Self {
    method truncate (line 184) | pub fn truncate(mut self) -> Self {
    method close_behavior (line 193) | pub fn close_behavior(mut self, close_behavior: PopupCloseBehavior) ->...
    method popup_style (line 203) | pub fn popup_style(mut self, popup_style: StyleModifier) -> Self {
    method show_ui (line 211) | pub fn show_ui<R>(
    method show_ui_dyn (line 219) | fn show_ui_dyn<'c, R>(
    method show_index (line 284) | pub fn show_index<Text: Into<WidgetText>>(
    method is_open (line 313) | pub fn is_open(ctx: &Context, id: Id) -> bool {
    method widget_to_popup_id (line 318) | fn widget_to_popup_id(widget_id: Id) -> Id {
  function combo_box_dyn (line 324) | fn combo_box_dyn<'c, R>(
  function button_frame (line 428) | fn button_frame(
  function paint_default_icon (line 476) | fn paint_default_icon(painter: &Painter, rect: Rect, visuals: &WidgetVis...

FILE: crates/egui/src/containers/frame.rs
  type Frame (line 96) | pub struct Frame {
    constant NONE (line 161) | pub const NONE: Self = Self {
    method new (line 173) | pub const fn new() -> Self {
    method none (line 178) | pub const fn none() -> Self {
    method group (line 183) | pub fn group(style: &Style) -> Self {
    method side_top_panel (line 190) | pub fn side_top_panel(style: &Style) -> Self {
    method central_panel (line 196) | pub fn central_panel(style: &Style) -> Self {
    method window (line 200) | pub fn window(style: &Style) -> Self {
    method menu (line 209) | pub fn menu(style: &Style) -> Self {
    method popup (line 218) | pub fn popup(style: &Style) -> Self {
    method canvas (line 231) | pub fn canvas(style: &Style) -> Self {
    method dark_canvas (line 240) | pub fn dark_canvas(style: &Style) -> Self {
    method inner_margin (line 252) | pub fn inner_margin(mut self, inner_margin: impl Into<Margin>) -> Self {
    method fill (line 262) | pub fn fill(mut self, fill: Color32) -> Self {
    method stroke (line 271) | pub fn stroke(mut self, stroke: impl Into<Stroke>) -> Self {
    method corner_radius (line 281) | pub fn corner_radius(mut self, corner_radius: impl Into<CornerRadius>)...
    method rounding (line 292) | pub fn rounding(self, corner_radius: impl Into<CornerRadius>) -> Self {
    method outer_margin (line 310) | pub fn outer_margin(mut self, outer_margin: impl Into<Margin>) -> Self {
    method shadow (line 317) | pub fn shadow(mut self, shadow: Shadow) -> Self {
    method multiply_with_opacity (line 327) | pub fn multiply_with_opacity(mut self, opacity: f32) -> Self {
    method total_margin (line 341) | pub fn total_margin(&self) -> MarginF32 {
    method fill_rect (line 350) | pub fn fill_rect(&self, content_rect: Rect) -> Rect {
    method widget_rect (line 357) | pub fn widget_rect(&self, content_rect: Rect) -> Rect {
    method outer_rect (line 364) | pub fn outer_rect(&self, content_rect: Rect) -> Rect {
    method begin (line 392) | pub fn begin(self, ui: &mut Ui) -> Prepared {
    method show (line 416) | pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -...
    method show_dyn (line 421) | pub fn show_dyn<'c, R>(
    method paint (line 433) | pub fn paint(&self, content_rect: Rect) -> Shape {
  function frame_size (line 144) | fn frame_size() {
  type Prepared (line 371) | pub struct Prepared {
    method outer_rect (line 463) | fn outer_rect(&self) -> Rect {
    method allocate_space (line 476) | pub fn allocate_space(&self, ui: &mut Ui) -> Response {
    method paint (line 483) | pub fn paint(&self, ui: &Ui) {
    method end (line 496) | pub fn end(self, ui: &mut Ui) -> Response {

FILE: crates/egui/src/containers/menu.rs
  function menu_style (line 22) | pub fn menu_style(style: &mut Style) {
  function find_menu_root (line 32) | pub fn find_menu_root(ui: &Ui) -> &UiStack {
  function is_in_menu (line 47) | pub fn is_in_menu(ui: &Ui) -> bool {
  type MenuConfig (line 65) | pub struct MenuConfig {
    constant MENU_CONFIG_TAG (line 90) | pub const MENU_CONFIG_TAG: &'static str = "egui_menu_config";
    method new (line 92) | pub fn new() -> Self {
    method close_behavior (line 98) | pub fn close_behavior(mut self, close_behavior: PopupCloseBehavior) ->...
    method style (line 107) | pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
    method from_stack (line 112) | fn from_stack(stack: &UiStack) -> Self {
    method find (line 124) | pub fn find(ui: &Ui) -> Self {
  method default (line 79) | fn default() -> Self {
  type MenuState (line 136) | pub struct MenuState {
    constant ID (line 143) | pub const ID: &'static str = "menu_state";
    method from_ui (line 146) | pub fn from_ui<R>(ui: &Ui, f: impl FnOnce(&mut Self, &UiStack) -> R) -...
    method from_id (line 152) | pub fn from_id<R>(ctx: &Context, id: Id, f: impl FnOnce(&mut Self) -> ...
    method mark_shown (line 178) | pub fn mark_shown(ctx: &Context, id: Id) {
    method is_deepest_open_sub_menu (line 188) | pub fn is_deepest_open_sub_menu(ctx: &Context, id: Id) -> bool {
  type MenuBar (line 217) | pub struct MenuBar {
    method new (line 235) | pub fn new() -> Self {
    method style (line 244) | pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
    method config (line 253) | pub fn config(mut self, config: MenuConfig) -> Self {
    method ui (line 260) | pub fn ui<R>(self, ui: &mut Ui, content: impl FnOnce(&mut Ui) -> R) ->...
  type Bar (line 223) | pub type Bar = MenuBar;
  method default (line 226) | fn default() -> Self {
  type MenuButton (line 293) | pub struct MenuButton<'a> {
  function new (line 299) | pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
  function config (line 305) | pub fn config(mut self, config: MenuConfig) -> Self {
  function from_button (line 312) | pub fn from_button(button: Button<'a>) -> Self {
  function ui (line 320) | pub fn ui<R>(
  type SubMenuButton (line 340) | pub struct SubMenuButton<'a> {
  constant RIGHT_ARROW (line 347) | pub const RIGHT_ARROW: &'static str = "⏵";
  function new (line 349) | pub fn new(atoms: impl IntoAtoms<'a>) -> Self {
  function from_button (line 357) | pub fn from_button(button: Button<'a>) -> Self {
  function config (line 368) | pub fn config(mut self, config: MenuConfig) -> Self {
  function ui (line 374) | pub fn ui<R>(
  type SubMenu (line 402) | pub struct SubMenu {
    method new (line 407) | pub fn new() -> Self {
    method config (line 415) | pub fn config(mut self, config: MenuConfig) -> Self {
    method id_from_widget_id (line 421) | pub fn id_from_widget_id(widget_id: Id) -> Id {
    method show (line 429) | pub fn show<R>(

FILE: crates/egui/src/containers/modal.rs
  type Modal (line 16) | pub struct Modal {
    method new (line 26) | pub fn new(id: Id) -> Self {
    method default_area (line 40) | pub fn default_area(id: Id) -> Area {
    method frame (line 53) | pub fn frame(mut self, frame: Frame) -> Self {
    method backdrop_color (line 62) | pub fn backdrop_color(mut self, color: Color32) -> Self {
    method area (line 71) | pub fn area(mut self, area: Area) -> Self {
    method show (line 77) | pub fn show<T>(self, ctx: &Context, content: impl FnOnce(&mut Ui) -> T...
  type ModalResponse (line 124) | pub struct ModalResponse<T> {
  function should_close (line 151) | pub fn should_close(&self) -> bool {

FILE: crates/egui/src/containers/old_popup.rs
  function show_tooltip (line 31) | pub fn show_tooltip<R>(
  function show_tooltip_at_pointer (line 58) | pub fn show_tooltip_at_pointer<R>(
  function show_tooltip_for (line 74) | pub fn show_tooltip_for<R>(
  function show_tooltip_at (line 90) | pub fn show_tooltip_at<R>(
  function show_tooltip_text (line 118) | pub fn show_tooltip_text(
  function was_tooltip_open_last_frame (line 131) | pub fn was_tooltip_open_last_frame(ctx: &Context, widget_id: Id) -> bool {
  type AboveOrBelow (line 137) | pub enum AboveOrBelow {
  function popup_below_widget (line 144) | pub fn popup_below_widget<R>(
  function popup_above_or_below_widget (line 189) | pub fn popup_above_or_below_widget<R>(

FILE: crates/egui/src/containers/panel.rs
  function animate_expansion (line 26) | fn animate_expansion(ctx: &Context, id: Id, is_expanded: bool) -> f32 {
  type PanelState (line 33) | pub struct PanelState {
    method load (line 38) | pub fn load(ctx: &Context, bar_id: Id) -> Option<Self> {
    method size (line 43) | pub fn size(&self) -> Vec2 {
    method store (line 47) | fn store(self, ctx: &Context, bar_id: Id) {
  type VerticalSide (line 56) | enum VerticalSide {
    method opposite (line 62) | pub fn opposite(self) -> Self {
    method set_rect_width (line 73) | fn set_rect_width(self, rect: &mut Rect, width: f32) {
    method sign (line 80) | fn sign(self) -> f32 {
    method side_x (line 87) | fn side_x(self, rect: Rect) -> f32 {
  type HorizontalSide (line 97) | enum HorizontalSide {
    method opposite (line 103) | pub fn opposite(self) -> Self {
    method set_rect_height (line 114) | fn set_rect_height(self, rect: &mut Rect, height: f32) {
    method sign (line 121) | fn sign(self) -> f32 {
    method side_y (line 128) | fn side_y(self, rect: Rect) -> f32 {
  type PanelSide (line 141) | enum PanelSide {
    method from (line 150) | fn from(side: HorizontalSide) -> Self {
    method from (line 156) | fn from(side: VerticalSide) -> Self {
    constant LEFT (line 162) | pub const LEFT: Self = Self::Vertical(VerticalSide::Left);
    constant RIGHT (line 163) | pub const RIGHT: Self = Self::Vertical(VerticalSide::Right);
    constant TOP (line 164) | pub const TOP: Self = Self::Horizontal(HorizontalSide::Top);
    constant BOTTOM (line 165) | pub const BOTTOM: Self = Self::Horizontal(HorizontalSide::Bottom);
    method set_rect_size (line 168) | fn set_rect_size(self, rect: &mut Rect, size: f32) {
    method ui_kind (line 175) | fn ui_kind(self) -> UiKind {
  type PanelSizer (line 192) | struct PanelSizer<'a> {
  function new (line 201) | fn new(panel: &'a Panel, ui: &Ui) -> Self {
  function get_size_from_state_or_default (line 218) | fn get_size_from_state_or_default(panel: &Panel, ui: &Ui, frame: Frame) ...
  function panel_rect (line 236) | fn panel_rect(panel: &Panel, available_rect: Rect, mut size: f32) -> Rect {
  function prepare_resizing_response (line 254) | fn prepare_resizing_response(&mut self, is_resizing: bool, pointer: Opti...
  type Panel (line 299) | pub struct Panel {
    method left (line 319) | pub fn left(id: impl Into<Id>) -> Self {
    method right (line 326) | pub fn right(id: impl Into<Id>) -> Self {
    method top (line 335) | pub fn top(id: impl Into<Id>) -> Self {
    method bottom (line 344) | pub fn bottom(id: impl Into<Id>) -> Self {
    method new (line 351) | fn new(side: PanelSide, id: impl Into<Id>) -> Self {
    method resizable (line 388) | pub fn resizable(mut self, resizable: bool) -> Self {
    method show_separator_line (line 397) | pub fn show_separator_line(mut self, show_separator_line: bool) -> Self {
    method default_size (line 404) | pub fn default_size(mut self, default_size: f32) -> Self {
    method min_size (line 415) | pub fn min_size(mut self, min_size: f32) -> Self {
    method max_size (line 422) | pub fn max_size(mut self, max_size: f32) -> Self {
    method size_range (line 429) | pub fn size_range(mut self, size_range: impl Into<Rangef>) -> Self {
    method exact_size (line 440) | pub fn exact_size(mut self, size: f32) -> Self {
    method frame (line 448) | pub fn frame(mut self, frame: Frame) -> Self {
    method default_width (line 457) | pub fn default_width(self, default_size: f32) -> Self {
    method min_width (line 462) | pub fn min_width(self, min_size: f32) -> Self {
    method max_width (line 467) | pub fn max_width(self, max_size: f32) -> Self {
    method width_range (line 472) | pub fn width_range(self, size_range: impl Into<Rangef>) -> Self {
    method exact_width (line 477) | pub fn exact_width(self, size: f32) -> Self {
    method default_height (line 482) | pub fn default_height(self, default_size: f32) -> Self {
    method min_height (line 487) | pub fn min_height(self, min_size: f32) -> Self {
    method max_height (line 492) | pub fn max_height(self, max_size: f32) -> Self {
    method height_range (line 497) | pub fn height_range(self, size_range: impl Into<Rangef>) -> Self {
    method exact_height (line 502) | pub fn exact_height(self, size: f32) -> Self {
    method show_inside (line 510) | pub fn show_inside<R>(
    method show (line 520) | pub fn show<R>(
    method show_animated (line 531) | pub fn show_animated<R>(
    method show_animated_inside (line 555) | pub fn show_animated_inside<R>(
    method show_animated_between (line 578) | pub fn show_animated_between<R>(
    method show_animated_between_inside (line 605) | pub fn show_animated_between_inside<R>(
    method show_inside_dyn (line 636) | fn show_inside_dyn<'c, R>(
    method show_dyn (line 756) | fn show_dyn<'c, R>(
    method prepare_resizable_panel (line 808) | fn prepare_resizable_panel(&self, panel_sizer: &mut PanelSizer<'_>, ui...
    method resize_panel (line 821) | fn resize_panel(&self, panel_sizer: &PanelSizer<'_>, ui: &Ui) -> (bool...
    method cursor_icon (line 850) | fn cursor_icon(&self, panel_sizer: &PanelSizer<'_>) -> CursorIcon {
    method get_animated_panel (line 882) | fn get_animated_panel(self, ctx: &Context, is_expanded: bool) -> Optio...
    method get_animated_between_panel (line 908) | fn get_animated_between_panel(
    method animated_size (line 935) | fn animated_size(ctx: &Context, panel: &Self) -> f32 {
  type CentralPanel (line 982) | pub struct CentralPanel {
    method no_frame (line 988) | pub fn no_frame() -> Self {
    method default_margins (line 995) | pub fn default_margins() -> Self {
    method frame (line 1001) | pub fn frame(mut self, frame: Frame) -> Self {
    method show_inside (line 1007) | pub fn show_inside<R>(
    method show_inside_dyn (line 1016) | fn show_inside_dyn<'c, R>(
    method show (line 1046) | pub fn show<R>(
    method show_dyn (line 1055) | fn show_dyn<'c, R>(
  function clamp_to_range (line 1089) | fn clamp_to_range(x: f32, range: Rangef) -> f32 {
  type SidePanel (line 1097) | pub type SidePanel = super::Panel;
  type TopBottomPanel (line 1100) | pub type TopBottomPanel = super::Panel;

FILE: crates/egui/src/containers/popup.rs
  type PopupAnchor (line 26) | pub enum PopupAnchor {
    method from (line 41) | fn from(rect: Rect) -> Self {
    method from (line 47) | fn from(pos: Pos2) -> Self {
    method from (line 53) | fn from(response: &Response) -> Self {
    method rect (line 67) | pub fn rect(self, popup_id: Id, ctx: &Context) -> Option<Rect> {
  type PopupCloseBehavior (line 79) | pub enum PopupCloseBehavior {
  type SetOpenCommand (line 96) | pub enum SetOpenCommand {
    method from (line 105) | fn from(b: bool) -> Self {
  type OpenKind (line 111) | enum OpenKind<'a> {
  function is_open (line 127) | fn is_open(&self, popup_id: Id, ctx: &Context) -> bool {
  type PopupKind (line 139) | pub enum PopupKind {
    method order (line 147) | pub fn order(self) -> Order {
  method from (line 156) | fn from(kind: PopupKind) -> Self {
  type Popup (line 167) | pub struct Popup<'a> {
  function new (line 192) | pub fn new(id: Id, ctx: Context, anchor: impl Into<PopupAnchor>, layer_i...
  function from_response (line 217) | pub fn from_response(response: &Response) -> Self {
  function from_toggle_button_response (line 230) | pub fn from_toggle_button_response(button_response: &Response) -> Self {
  function menu (line 237) | pub fn menu(button_response: &Response) -> Self {
  function context_menu (line 248) | pub fn context_menu(response: &Response) -> Self {
  function kind (line 264) | pub fn kind(mut self, kind: PopupKind) -> Self {
  function info (line 271) | pub fn info(mut self, info: UiStackInfo) -> Self {
  function align (line 280) | pub fn align(mut self, position_align: RectAlign) -> Self {
  function align_alternatives (line 289) | pub fn align_alternatives(mut self, alternatives: &'a [RectAlign]) -> Se...
  function open (line 296) | pub fn open(mut self, open: bool) -> Self {
  function open_memory (line 308) | pub fn open_memory(mut self, set_state: impl Into<Option<SetOpenCommand>...
  function open_bool (line 317) | pub fn open_bool(mut self, open: &'a mut bool) -> Self {
  function close_behavior (line 326) | pub fn close_behavior(mut self, close_behavior: PopupCloseBehavior) -> S...
  function at_pointer (line 333) | pub fn at_pointer(mut self) -> Self {
  function at_pointer_fixed (line 341) | pub fn at_pointer_fixed(mut self) -> Self {
  function at_position (line 348) | pub fn at_position(mut self, position: Pos2) -> Self {
  function anchor (line 355) | pub fn anchor(mut self, anchor: impl Into<PopupAnchor>) -> Self {
  function gap (line 362) | pub fn gap(mut self, gap: f32) -> Self {
  function frame (line 369) | pub fn frame(mut self, frame: Frame) -> Self {
  function sense (line 376) | pub fn sense(mut self, sense: Sense) -> Self {
  function layout (line 383) | pub fn layout(mut self, layout: Layout) -> Self {
  function width (line 390) | pub fn width(mut self, width: f32) -> Self {
  function id (line 397) | pub fn id(mut self, id: Id) -> Self {
  function style (line 408) | pub fn style(mut self, style: impl Into<StyleModifier>) -> Self {
  function ctx (line 414) | pub fn ctx(&self) -> &Context {
  function get_anchor (line 419) | pub fn get_anchor(&self) -> PopupAnchor {
  function get_anchor_rect (line 426) | pub fn get_anchor_rect(&self) -> Option<Rect> {
  function get_popup_rect (line 434) | pub fn get_popup_rect(&self) -> Option<Rect> {
  function get_id (line 445) | pub fn get_id(&self) -> Id {
  function is_open (line 450) | pub fn is_open(&self) -> bool {
  function get_expected_size (line 460) | pub fn get_expected_size(&self) -> Option<Vec2> {
  function get_best_align (line 465) | pub fn get_best_align(&self) -> RectAlign {
  function show (line 501) | pub fn show<R>(self, content: impl FnOnce(&mut Ui) -> R) -> Option<Inner...
  function default_response_id (line 643) | pub fn default_response_id(response: &Response) -> Id {
  function is_id_open (line 657) | pub fn is_id_open(ctx: &Context, popup_id: Id) -> bool {
  function is_any_open (line 664) | pub fn is_any_open(ctx: &Context) -> bool {
  function open_id (line 673) | pub fn open_id(ctx: &Context, popup_id: Id) {
  function toggle_id (line 680) | pub fn toggle_id(ctx: &Context, popup_id: Id) {
  function close_all (line 685) | pub fn close_all(ctx: &Context) {
  function close_id (line 692) | pub fn close_id(ctx: &Context, popup_id: Id) {
  function position_of_id (line 697) | pub fn position_of_id(ctx: &Context, popup_id: Id) -> Option<Pos2> {

FILE: crates/egui/src/containers/resize.rs
  type State (line 8) | pub(crate) struct State {
    method load (line 23) | pub fn load(ctx: &Context, id: Id) -> Option<Self> {
    method store (line 27) | pub fn store(self, ctx: &Context, id: Id) {
  type Resize (line 35) | pub struct Resize {
    method id (line 67) | pub fn id(mut self, id: Id) -> Self {
    method id_source (line 75) | pub fn id_source(self, id_salt: impl std::hash::Hash) -> Self {
    method id_salt (line 81) | pub fn id_salt(mut self, id_salt: impl std::hash::Hash) -> Self {
    method default_width (line 93) | pub fn default_width(mut self, width: f32) -> Self {
    method default_height (line 106) | pub fn default_height(mut self, height: f32) -> Self {
    method default_size (line 112) | pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
    method min_size (line 119) | pub fn min_size(mut self, min_size: impl Into<Vec2>) -> Self {
    method min_width (line 126) | pub fn min_width(mut self, min_width: f32) -> Self {
    method min_height (line 133) | pub fn min_height(mut self, min_height: f32) -> Self {
    method max_size (line 140) | pub fn max_size(mut self, max_size: impl Into<Vec2>) -> Self {
    method max_width (line 147) | pub fn max_width(mut self, max_width: f32) -> Self {
    method max_height (line 154) | pub fn max_height(mut self, max_height: f32) -> Self {
    method resizable (line 165) | pub fn resizable(mut self, resizable: impl Into<Vec2b>) -> Self {
    method is_resizable (line 171) | pub fn is_resizable(&self) -> Vec2b {
    method auto_sized (line 177) | pub fn auto_sized(self) -> Self {
    method fixed_size (line 184) | pub fn fixed_size(mut self, size: impl Into<Vec2>) -> Self {
    method with_stroke (line 194) | pub fn with_stroke(mut self, with_stroke: bool) -> Self {
    method begin (line 208) | fn begin(&self, ui: &mut Ui) -> Prepared {
    method show (line 298) | pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -...
    method end (line 305) | fn end(self, ui: &mut Ui, prepared: Prepared) {
  method default (line 51) | fn default() -> Self {
  type Prepared (line 200) | struct Prepared {
  function paint_resize_corner (line 390) | pub fn paint_resize_corner(ui: &Ui, response: &Response) {
  function paint_resize_corner_with_style (line 395) | pub fn paint_resize_corner_with_style(

FILE: crates/egui/src/containers/scene.rs
  function fit_to_rect_in_scene (line 15) | fn fit_to_rect_in_scene(
  type Scene (line 46) | pub struct Scene {
    method new (line 89) | pub fn new() -> Self {
    method sense (line 99) | pub fn sense(mut self, sense: Sense) -> Self {
    method zoom_range (line 112) | pub fn zoom_range(mut self, zoom_range: impl Into<Rangef>) -> Self {
    method max_inner_size (line 119) | pub fn max_inner_size(mut self, max_inner_size: impl Into<Vec2>) -> Se...
    method drag_pan_buttons (line 128) | pub fn drag_pan_buttons(mut self, flags: DragPanButtons) -> Self {
    method show (line 140) | pub fn show<R>(
    method show_global_transform (line 178) | fn show_global_transform<R>(
    method register_pan_and_zoom (line 229) | pub fn register_pan_and_zoom(&self, ui: &Ui, resp: &mut Response, to_g...
  type DragPanButtons (line 55) | pub struct DragPanButtons(u8);
  method default (line 77) | fn default() -> Self {

FILE: crates/egui/src/containers/scroll_area.rs
  type ScrollingToTarget (line 18) | struct ScrollingToTarget {
  type State (line 26) | pub struct State {
    method load (line 75) | pub fn load(ctx: &Context, id: Id) -> Option<Self> {
    method store (line 79) | pub fn store(self, ctx: &Context, id: Id) {
    method velocity (line 84) | pub fn velocity(&self) -> Vec2 {
  method default (line 59) | fn default() -> Self {
  type ScrollAreaOutput (line 89) | pub struct ScrollAreaOutput<R> {
  type ScrollBarVisibility (line 110) | pub enum ScrollBarVisibility {
    constant ALL (line 137) | pub const ALL: [Self; 3] = [
  method default (line 131) | fn default() -> Self {
  type ScrollSource (line 147) | pub struct ScrollSource {
    constant NONE (line 169) | pub const NONE: Self = Self {
    constant ALL (line 174) | pub const ALL: Self = Self {
    constant SCROLL_BAR (line 179) | pub const SCROLL_BAR: Self = Self {
    constant DRAG (line 184) | pub const DRAG: Self = Self {
    constant MOUSE_WHEEL (line 189) | pub const MOUSE_WHEEL: Self = Self {
    method is_none (line 197) | pub fn is_none(&self) -> bool {
    method any (line 203) | pub fn any(&self) -> bool {
    method is_all (line 209) | pub fn is_all(&self) -> bool {
  method default (line 163) | fn default() -> Self {
  type Output (line 215) | type Output = Self;
  method bitor (line 218) | fn bitor(self, rhs: Self) -> Self::Output {
  type Output (line 229) | type Output = Self;
  method add (line 232) | fn add(self, rhs: Self) -> Self::Output {
  method bitor_assign (line 239) | fn bitor_assign(&mut self, rhs: Self) {
  method add_assign (line 246) | fn add_assign(&mut self, rhs: Self) {
  type ScrollArea (line 284) | pub struct ScrollArea {
    method horizontal (line 315) | pub fn horizontal() -> Self {
    method vertical (line 321) | pub fn vertical() -> Self {
    method both (line 327) | pub fn both() -> Self {
    method neither (line 334) | pub fn neither() -> Self {
    method new (line 340) | pub fn new(direction_enabled: impl Into<Vec2b>) -> Self {
    method max_width (line 367) | pub fn max_width(mut self, max_width: f32) -> Self {
    method max_height (line 378) | pub fn max_height(mut self, max_height: f32) -> Self {
    method min_scrolled_width (line 390) | pub fn min_scrolled_width(mut self, min_scrolled_width: f32) -> Self {
    method min_scrolled_height (line 402) | pub fn min_scrolled_height(mut self, min_scrolled_height: f32) -> Self {
    method scroll_bar_visibility (line 411) | pub fn scroll_bar_visibility(mut self, scroll_bar_visibility: ScrollBa...
    method scroll_bar_rect (line 421) | pub fn scroll_bar_rect(mut self, scroll_bar_rect: Rect) -> Self {
    method id_source (line 429) | pub fn id_source(self, id_salt: impl std::hash::Hash) -> Self {
    method id_salt (line 435) | pub fn id_salt(mut self, id_salt: impl std::hash::Hash) -> Self {
    method scroll_offset (line 448) | pub fn scroll_offset(mut self, offset: Vec2) -> Self {
    method vertical_scroll_offset (line 461) | pub fn vertical_scroll_offset(mut self, offset: f32) -> Self {
    method horizontal_scroll_offset (line 473) | pub fn horizontal_scroll_offset(mut self, offset: f32) -> Self {
    method on_hover_cursor (line 485) | pub fn on_hover_cursor(mut self, cursor: CursorIcon) -> Self {
    method on_drag_cursor (line 497) | pub fn on_drag_cursor(mut self, cursor: CursorIcon) -> Self {
    method hscroll (line 504) | pub fn hscroll(mut self, hscroll: bool) -> Self {
    method vscroll (line 511) | pub fn vscroll(mut self, vscroll: bool) -> Self {
    method scroll (line 520) | pub fn scroll(mut self, direction_enabled: impl Into<Vec2b>) -> Self {
    method enable_scrolling (line 536) | pub fn enable_scrolling(mut self, enable: bool) -> Self {
    method drag_to_scroll (line 554) | pub fn drag_to_scroll(mut self, drag_to_scroll: bool) -> Self {
    method scroll_source (line 561) | pub fn scroll_source(mut self, scroll_source: ScrollSource) -> Self {
    method wheel_scroll_multiplier (line 572) | pub fn wheel_scroll_multiplier(mut self, multiplier: Vec2) -> Self {
    method auto_shrink (line 584) | pub fn auto_shrink(mut self, auto_shrink: impl Into<Vec2b>) -> Self {
    method animated (line 593) | pub fn animated(mut self, animated: bool) -> Self {
    method is_any_scroll_enabled (line 599) | pub(crate) fn is_any_scroll_enabled(&self) -> bool {
    method content_margin (line 610) | pub fn content_margin(mut self, margin: impl Into<Margin>) -> Self {
    method stick_to_right (line 622) | pub fn stick_to_right(mut self, stick: bool) -> Self {
    method stick_to_bottom (line 634) | pub fn stick_to_bottom(mut self, stick: bool) -> Self {
    method begin (line 690) | fn begin(self, ui: &mut Ui) -> Prepared {
    method show (line 932) | pub fn show<R>(
    method show_rows (line 956) | pub fn show_rows<R>(
    method show_viewport (line 993) | pub fn show_viewport<R>(
    method show_viewport_dyn (line 1001) | fn show_viewport_dyn<'c, R>(
  type Prepared (line 640) | struct Prepared {
    method end (line 1034) | fn end(self, ui: &mut Ui) -> (Vec2, State) {

FILE: crates/egui/src/containers/sides.rs
  type Sides (line 45) | pub struct Sides {
    method new (line 62) | pub fn new() -> Self {
    method height (line 71) | pub fn height(mut self, height: f32) -> Self {
    method spacing (line 81) | pub fn spacing(mut self, spacing: f32) -> Self {
    method shrink_left (line 91) | pub fn shrink_left(mut self) -> Self {
    method shrink_right (line 101) | pub fn shrink_right(mut self) -> Self {
    method extend (line 111) | pub fn extend(mut self) -> Self {
    method wrap_mode (line 120) | pub fn wrap_mode(mut self, wrap_mode: crate::TextWrapMode) -> Self {
    method truncate (line 130) | pub fn truncate(mut self) -> Self {
    method wrap (line 140) | pub fn wrap(mut self) -> Self {
    method show (line 145) | pub fn show<RetL, RetR>(
    method create_ui (line 243) | fn create_ui<Ret>(
  type SidesKind (line 53) | enum SidesKind {

FILE: crates/egui/src/containers/tooltip.rs
  type Tooltip (line 8) | pub struct Tooltip<'a> {
  function new (line 21) | pub fn new(
  function always_open (line 38) | pub fn always_open(
  function for_widget (line 57) | pub fn for_widget(response: &Response) -> Self {
  function for_enabled (line 71) | pub fn for_enabled(response: &Response) -> Self {
  function for_disabled (line 80) | pub fn for_disabled(response: &Response) -> Self {
  function at_pointer (line 90) | pub fn at_pointer(mut self) -> Self {
  function gap (line 99) | pub fn gap(mut self, gap: f32) -> Self {
  function layout (line 106) | pub fn layout(mut self, layout: Layout) -> Self {
  function width (line 113) | pub fn width(mut self, width: f32) -> Self {
  function show (line 119) | pub fn show<R>(self, content: impl FnOnce(&mut crate::Ui) -> R) -> Optio...
  function when_was_a_toolip_last_shown_id (line 177) | fn when_was_a_toolip_last_shown_id() -> Id {
  function seconds_since_last_tooltip (line 181) | pub fn seconds_since_last_tooltip(ctx: &Context) -> f32 {
  function remember_that_tooltip_was_shown (line 193) | fn remember_that_tooltip_was_shown(ctx: &Context) {
  function next_tooltip_id (line 199) | pub fn next_tooltip_id(ctx: &Context, widget_id: Id) -> Id {
  function tooltip_id (line 209) | pub fn tooltip_id(widget_id: Id, tooltip_count: usize) -> Id {
  function should_show_tooltip (line 217) | pub fn should_show_tooltip(response: &Response, allow_interactive_toolti...
  function was_tooltip_open_last_frame (line 396) | pub fn was_tooltip_open_last_frame(ctx: &Context, widget_id: Id) -> bool {

FILE: crates/egui/src/containers/window.rs
  type Window (line 36) | pub struct Window<'open> {
  function new (line 53) | pub fn new(title: impl Into<WidgetText>) -> Self {
  function from_viewport (line 74) | pub fn from_viewport(id: ViewportId, viewport: ViewportBuilder) -> Self {
  function id (line 110) | pub fn id(mut self, id: Id) -> Self {
  function open (line 121) | pub fn open(mut self, open: &'open mut bool) -> Self {
  function enabled (line 128) | pub fn enabled(mut self, enabled: bool) -> Self {
  function interactable (line 139) | pub fn interactable(mut self, interactable: bool) -> Self {
  function movable (line 146) | pub fn movable(mut self, movable: bool) -> Self {
  function order (line 153) | pub fn order(mut self, order: Order) -> Self {
  function fade_in (line 162) | pub fn fade_in(mut self, fade_in: bool) -> Self {
  function fade_out (line 173) | pub fn fade_out(mut self, fade_out: bool) -> Self {
  function mutate (line 181) | pub fn mutate(mut self, mutate: impl Fn(&mut Self)) -> Self {
  function resize (line 189) | pub fn resize(mut self, mutate: impl Fn(Resize) -> Resize) -> Self {
  function frame (line 196) | pub fn frame(mut self, frame: Frame) -> Self {
  function min_width (line 203) | pub fn min_width(mut self, min_width: f32) -> Self {
  function min_height (line 210) | pub fn min_height(mut self, min_height: f32) -> Self {
  function min_size (line 217) | pub fn min_size(mut self, min_size: impl Into<Vec2>) -> Self {
  function max_width (line 224) | pub fn max_width(mut self, max_width: f32) -> Self {
  function max_height (line 231) | pub fn max_height(mut self, max_height: f32) -> Self {
  function max_size (line 238) | pub fn max_size(mut self, max_size: impl Into<Vec2>) -> Self {
  function current_pos (line 246) | pub fn current_pos(mut self, current_pos: impl Into<Pos2>) -> Self {
  function default_pos (line 253) | pub fn default_pos(mut self, default_pos: impl Into<Pos2>) -> Self {
  function fixed_pos (line 260) | pub fn fixed_pos(mut self, pos: impl Into<Pos2>) -> Self {
  function constrain (line 271) | pub fn constrain(mut self, constrain: bool) -> Self {
  function constrain_to (line 280) | pub fn constrain_to(mut self, constrain_rect: Rect) -> Self {
  function pivot (line 293) | pub fn pivot(mut self, pivot: Align2) -> Self {
  function anchor (line 310) | pub fn anchor(mut self, align: Align2, offset: impl Into<Vec2>) -> Self {
  function default_open (line 317) | pub fn default_open(mut self, default_open: bool) -> Self {
  function default_size (line 324) | pub fn default_size(mut self, default_size: impl Into<Vec2>) -> Self {
  function default_width (line 333) | pub fn default_width(mut self, default_width: f32) -> Self {
  function default_height (line 341) | pub fn default_height(mut self, default_height: f32) -> Self {
  function fixed_size (line 349) | pub fn fixed_size(mut self, size: impl Into<Vec2>) -> Self {
  function default_rect (line 355) | pub fn default_rect(self, rect: Rect) -> Self {
  function fixed_rect (line 360) | pub fn fixed_rect(self, rect: Rect) -> Self {
  function resizable (line 374) | pub fn resizable(mut self, resizable: impl Into<Vec2b>) -> Self {
  function collapsible (line 382) | pub fn collapsible(mut self, collapsible: bool) -> Self {
  function title_bar (line 390) | pub fn title_bar(mut self, title_bar: bool) -> Self {
  function auto_sized (line 399) | pub fn auto_sized(mut self) -> Self {
  function scroll (line 409) | pub fn scroll(mut self, scroll: impl Into<Vec2b>) -> Self {
  function hscroll (line 416) | pub fn hscroll(mut self, hscroll: bool) -> Self {
  function vscroll (line 423) | pub fn vscroll(mut self, vscroll: bool) -> Self {
  function drag_to_scroll (line 432) | pub fn drag_to_scroll(mut self, drag_to_scroll: bool) -> Self {
  function scroll_bar_visibility (line 442) | pub fn scroll_bar_visibility(mut self, visibility: ScrollBarVisibility) ...
  function show (line 452) | pub fn show<R>(
  function show_dyn (line 460) | fn show_dyn<'c, R>(
  function paint_resize_corner (line 706) | fn paint_resize_corner(
  type PossibleInteractions (line 764) | struct PossibleInteractions {
    method new (line 773) | fn new(area: &Area, resize: &Resize, is_collapsed: bool) -> Self {
    method resizable (line 787) | pub fn resizable(&self) -> bool {
  type ResizeInteraction (line 794) | struct ResizeInteraction {
    method set_cursor (line 840) | pub fn set_cursor(&self, ctx: &Context) {
    method any_hovered (line 858) | pub fn any_hovered(&self) -> bool {
    method any_dragged (line 862) | pub fn any_dragged(&self) -> bool {
  type SideResponse (line 808) | struct SideResponse {
    method any (line 814) | pub fn any(&self) -> bool {
    type Output (line 820) | type Output = Self;
    method bitand (line 822) | fn bitand(self, rhs: Self) -> Self::Output {
    method bitor_assign (line 831) | fn bitor_assign(&mut self, rhs: Self) {
  function resize_response (line 867) | fn resize_response(
  function move_and_resize_window (line 897) | fn move_and_resize_window(ctx: &Context, id: Id, interaction: &ResizeInt...
  function do_resize_interaction (line 937) | fn do_resize_interaction(
  function paint_frame_interaction (line 1099) | fn paint_frame_interaction(ui: &Ui, rect: Rect, interaction: ResizeInter...
  type TitleBar (line 1179) | struct TitleBar {
    method new (line 1193) | fn new(
    method ui (line 1255) | fn ui(
    method close_button_ui (line 1340) | fn close_button_ui(&self, ui: &mut Ui) -> Response {
  function close_button (line 1361) | fn close_button(ui: &mut Ui, rect: Rect) -> Response {

FILE: crates/egui/src/context.rs
  type RequestRepaintInfo (line 49) | pub struct RequestRepaintInfo {
  type WrappedTextureManager (line 71) | struct WrappedTextureManager(Arc<RwLock<epaint::TextureManager>>);
  method default (line 74) | fn default() -> Self {
  type ViewportState (line 193) | pub struct ViewportState {
  type RepaintCause (line 250) | pub struct RepaintCause {
    method fmt (line 262) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method fmt (line 268) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 277) | pub fn new() -> Self {
    method new_reason (line 289) | pub fn new_reason(reason: impl Into<Cow<'static, str>>) -> Self {
  type ViewportRepaintInfo (line 300) | struct ViewportRepaintInfo {
    method requested_immediate_repaint_prev_pass (line 359) | pub fn requested_immediate_repaint_prev_pass(&self) -> bool {
  method default (line 339) | fn default() -> Self {
  type ContextImpl (line 367) | struct ContextImpl {
    method begin_pass_repaint_logic (line 98) | fn begin_pass_repaint_logic(&mut self, viewport_id: ViewportId) {
    method request_repaint (line 125) | fn request_repaint(&mut self, viewport_id: ViewportId, cause: RepaintC...
    method request_repaint_after (line 129) | fn request_repaint_after(
    method requested_immediate_repaint_prev_pass (line 172) | fn requested_immediate_repaint_prev_pass(&self, viewport_id: &Viewport...
    method has_requested_repaint (line 179) | fn has_requested_repaint(&self, viewport_id: &ViewportId) -> bool {
    method begin_pass (line 411) | fn begin_pass(&mut self, mut new_raw_input: RawInput) {
    method update_fonts_mut (line 530) | fn update_fonts_mut(&mut self) {
    method accesskit_node_builder (line 587) | fn accesskit_node_builder(&mut self, id: Id) -> Option<&mut accesskit:...
    method pixels_per_point (line 621) | fn pixels_per_point(&mut self) -> f32 {
    method viewport_id (line 628) | pub(crate) fn viewport_id(&self) -> ViewportId {
    method parent_viewport_id (line 635) | pub(crate) fn parent_viewport_id(&self) -> ViewportId {
    method all_viewport_ids (line 643) | fn all_viewport_ids(&self) -> ViewportIdSet {
    method viewport (line 652) | pub(crate) fn viewport(&mut self) -> &mut ViewportState {
    method viewport_for (line 656) | fn viewport_for(&mut self, viewport_id: ViewportId) -> &mut ViewportSt...
    method end_pass (line 2582) | fn end_pass(&mut self) -> FullOutput {
  type Context (line 714) | pub struct Context(Arc<RwLock<ContextImpl>>);
    method fmt (line 717) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method eq (line 723) | fn eq(&self, other: &Self) -> bool {
    method read (line 750) | fn read<R>(&self, reader: impl FnOnce(&ContextImpl) -> R) -> R {
    method write (line 755) | fn write<R>(&self, writer: impl FnOnce(&mut ContextImpl) -> R) -> R {
    method run_ui (line 787) | pub fn run_ui(&self, new_input: RawInput, mut run_ui: impl FnMut(&mut ...
    method run_ui_dyn (line 792) | fn run_ui_dyn(&self, new_input: RawInput, run_ui: &mut dyn FnMut(&mut ...
    method run (line 844) | pub fn run(&self, new_input: RawInput, mut run_ui: impl FnMut(&Self)) ...
    method run_dyn (line 849) | fn run_dyn(&self, mut new_input: RawInput, run_ui: &mut dyn FnMut(&Sel...
    method begin_pass (line 937) | pub fn begin_pass(&self, mut new_input: RawInput) {
    method begin_frame (line 948) | pub fn begin_frame(&self, new_input: RawInput) {
    method input (line 972) | pub fn input<R>(&self, reader: impl FnOnce(&InputState) -> R) -> R {
    method input_for (line 978) | pub fn input_for<R>(&self, id: ViewportId, reader: impl FnOnce(&InputS...
    method input_mut (line 984) | pub fn input_mut<R>(&self, writer: impl FnOnce(&mut InputState) -> R) ...
    method input_mut_for (line 990) | pub fn input_mut_for<R>(&self, id: ViewportId, writer: impl FnOnce(&mu...
    method memory (line 996) | pub fn memory<R>(&self, reader: impl FnOnce(&Memory) -> R) -> R {
    method memory_mut (line 1002) | pub fn memory_mut<R>(&self, writer: impl FnOnce(&mut Memory) -> R) -> R {
    method data (line 1008) | pub fn data<R>(&self, reader: impl FnOnce(&IdTypeMap) -> R) -> R {
    method data_mut (line 1014) | pub fn data_mut<R>(&self, writer: impl FnOnce(&mut IdTypeMap) -> R) ->...
    method graphics_mut (line 1020) | pub fn graphics_mut<R>(&self, writer: impl FnOnce(&mut GraphicLayers) ...
    method graphics (line 1026) | pub fn graphics<R>(&self, reader: impl FnOnce(&GraphicLayers) -> R) ->...
    method output (line 1039) | pub fn output<R>(&self, reader: impl FnOnce(&PlatformOutput) -> R) -> R {
    method output_mut (line 1045) | pub fn output_mut<R>(&self, writer: impl FnOnce(&mut PlatformOutput) -...
    method pass_state (line 1053) | pub(crate) fn pass_state<R>(&self, reader: impl FnOnce(&PassState) -> ...
    method pass_state_mut (line 1061) | pub(crate) fn pass_state_mut<R>(&self, writer: impl FnOnce(&mut PassSt...
    method prev_pass_state (line 1069) | pub(crate) fn prev_pass_state<R>(&self, reader: impl FnOnce(&PassState...
    method fonts (line 1078) | pub fn fonts<R>(&self, reader: impl FnOnce(&FontsView<'_>) -> R) -> R {
    method fonts_mut (line 1095) | pub fn fonts_mut<R>(&self, reader: impl FnOnce(&mut FontsView<'_>) -> ...
    method options (line 1110) | pub fn options<R>(&self, reader: impl FnOnce(&Options) -> R) -> R {
    method options_mut (line 1116) | pub fn options_mut<R>(&self, writer: impl FnOnce(&mut Options) -> R) -...
    method tessellation_options (line 1122) | pub fn tessellation_options<R>(&self, reader: impl FnOnce(&Tessellatio...
    method tessellation_options_mut (line 1128) | pub fn tessellation_options_mut<R>(
    method check_for_id_clash (line 1144) | pub fn check_for_id_clash(&self, id: Id, new_rect: Rect, what: &str) {
    method create_widget (line 1229) | pub(crate) fn create_widget(
    method read_response (line 1334) | pub fn read_response(&self, id: Id) -> Option<Response> {
    method get_response (line 1358) | pub(crate) fn get_response(&self, widget_rect: WidgetRect) -> Response {
    method register_widget_info (line 1507) | pub fn register_widget_info(&self, id: Id, make_info: impl Fn() -> cra...
    method layer_painter (line 1522) | pub fn layer_painter(&self, layer_id: LayerId) -> Painter {
    method debug_painter (line 1528) | pub fn debug_painter(&self) -> Painter {
    method debug_text (line 1546) | pub fn debug_text(&self, text: impl Into<WidgetText>) {
    method os (line 1557) | pub fn os(&self) -> OperatingSystem {
    method set_os (line 1565) | pub fn set_os(&self, os: OperatingSystem) {
    method set_cursor_icon (line 1576) | pub fn set_cursor_icon(&self, cursor_icon: CursorIcon) {
    method send_cmd (line 1582) | pub fn send_cmd(&self, cmd: crate::OutputCommand) {
    method open_url (line 1594) | pub fn open_url(&self, open_url: crate::OpenUrl) {
    method copy_text (line 1603) | pub fn copy_text(&self, text: String) {
    method copy_image (line 1612) | pub fn copy_image(&self, image: crate::ColorImage) {
    method can_show_modifier_symbols (line 1616) | fn can_show_modifier_symbols(&self) -> bool {
    method format_modifiers (line 1636) | pub fn format_modifiers(&self, modifiers: Modifiers) -> String {
    method format_shortcut (line 1651) | pub fn format_shortcut(&self, shortcut: &KeyboardShortcut) -> String {
    method cumulative_frame_nr (line 1668) | pub fn cumulative_frame_nr(&self) -> u64 {
    method cumulative_frame_nr_for (line 1677) | pub fn cumulative_frame_nr_for(&self, id: ViewportId) -> u64 {
    method cumulative_pass_nr (line 1698) | pub fn cumulative_pass_nr(&self) -> u64 {
    method cumulative_pass_nr_for (line 1705) | pub fn cumulative_pass_nr_for(&self, id: ViewportId) -> u64 {
    method current_pass_index (line 1721) | pub fn current_pass_index(&self) -> usize {
    method request_repaint (line 1738) | pub fn request_repaint(&self) {
    method request_repaint_of (line 1755) | pub fn request_repaint_of(&self, id: ViewportId) {
    method request_repaint_after (line 1789) | pub fn request_repaint_after(&self, duration: Duration) {
    method request_repaint_after_secs (line 1797) | pub fn request_repaint_after_secs(&self, seconds: f32) {
    method request_repaint_after_for (line 1832) | pub fn request_repaint_after_for(&self, duration: Duration, id: Viewpo...
    method requested_repaint_last_pass (line 1839) | pub fn requested_repaint_last_pass(&self) -> bool {
    method requested_repaint_last_pass_for (line 1845) | pub fn requested_repaint_last_pass_for(&self, viewport_id: &ViewportId...
    method has_requested_repaint (line 1851) | pub fn has_requested_repaint(&self) -> bool {
    method has_requested_repaint_for (line 1857) | pub fn has_requested_repaint_for(&self, viewport_id: &ViewportId) -> b...
    method repaint_causes (line 1864) | pub fn repaint_causes(&self) -> Vec<RepaintCause> {
    method set_request_repaint_callback (line 1878) | pub fn set_request_repaint_callback(
    method request_discard (line 1909) | pub fn request_discard(&self, reason: impl Into<Cow<'static, str>>) {
    method will_discard (line 1928) | pub fn will_discard(&self) -> bool {
    method on_begin_pass (line 1943) | pub fn on_begin_pass(&self, debug_name: &'static str, cb: plugin::Cont...
    method on_end_pass (line 1952) | pub fn on_end_pass(&self, debug_name: &'static str, cb: plugin::Contex...
    method add_plugin (line 1964) | pub fn add_plugin(&self, plugin: impl plugin::Plugin + 'static) {
    method with_plugin (line 1977) | pub fn with_plugin<T: plugin::Plugin + 'static, R>(
    method plugin (line 1989) | pub fn plugin<T: plugin::Plugin>(&self) -> TypedPluginHandle<T> {
    method plugin_opt (line 1998) | pub fn plugin_opt<T: plugin::Plugin>(&self) -> Option<TypedPluginHandl...
    method plugin_or_default (line 2004) | pub fn plugin_or_default<T: plugin::Plugin + Default>(&self) -> TypedP...
    method set_fonts (line 2023) | pub fn set_fonts(&self, font_definitions: FontDefinitions) {
    method add_font (line 2046) | pub fn add_font(&self, new_font: FontInsert) {
    method system_theme (line 2069) | pub fn system_theme(&self) -> Option<Theme> {
    method theme (line 2075) | pub fn theme(&self) -> Theme {
    method set_theme (line 2087) | pub fn set_theme(&self, theme_preference: impl Into<crate::ThemePrefer...
    method global_style (line 2092) | pub fn global_style(&self) -> Arc<Style> {
    method style (line 2098) | pub fn style(&self) -> Arc<Style> {
    method global_style_mut (line 2112) | pub fn global_style_mut(&self, mutate_style: impl FnOnce(&mut Style)) {
    method style_mut (line 2127) | pub fn style_mut(&self, mutate_style: impl FnOnce(&mut Style)) {
    method set_global_style (line 2138) | pub fn set_global_style(&self, style: impl Into<Arc<Style>>) {
    method set_style (line 2150) | pub fn set_style(&self, style: impl Into<Arc<Style>>) {
    method all_styles_mut (line 2163) | pub fn all_styles_mut(&self, mut mutate_style: impl FnMut(&mut Style)) {
    method style_of (line 2171) | pub fn style_of(&self, theme: Theme) -> Arc<Style> {
    method style_mut_of (line 2187) | pub fn style_mut_of(&self, theme: Theme, mutate_style: impl FnOnce(&mu...
    method set_style_of (line 2200) | pub fn set_style_of(&self, theme: Theme, style: impl Into<Arc<Style>>) {
    method set_visuals_of (line 2217) | pub fn set_visuals_of(&self, theme: Theme, visuals: crate::Visuals) {
    method set_visuals (line 2230) | pub fn set_visuals(&self, visuals: crate::Visuals) {
    method pixels_per_point (line 2238) | pub fn pixels_per_point(&self) -> f32 {
    method set_pixels_per_point (line 2246) | pub fn set_pixels_per_point(&self, pixels_per_point: f32) {
    method native_pixels_per_point (line 2257) | pub fn native_pixels_per_point(&self) -> Option<f32> {
    method zoom_factor (line 2269) | pub fn zoom_factor(&self) -> f32 {
    method set_zoom_factor (line 2287) | pub fn set_zoom_factor(&self, zoom_factor: f32) {
    method load_texture (line 2340) | pub fn load_texture(
    method tex_manager (line 2367) | pub fn tex_manager(&self) -> Arc<RwLock<epaint::textures::TextureManag...
    method constrain_window_rect_to_area (line 2374) | pub(crate) fn constrain_window_rect_to_area(window: Rect, area: Rect) ...
    method end_pass (line 2393) | pub fn end_pass(&self) -> FullOutput {
    method end_frame (line 2420) | pub fn end_frame(&self) -> FullOutput {
    method debug_painting (line 2426) | fn debug_painting(&self) {
    method tessellate (line 2771) | pub fn tessellate(
    method content_rect (line 2819) | pub fn content_rect(&self) -> Rect {
    method viewport_rect (line 2833) | pub fn viewport_rect(&self) -> Rect {
    method screen_rect (line 2841) | pub fn screen_rect(&self) -> Rect {
    method available_rect (line 2847) | pub fn available_rect(&self) -> Rect {
    method globally_used_rect (line 2852) | pub fn globally_used_rect(&self) -> Rect {
    method used_rect (line 2864) | pub fn used_rect(&self) -> Rect {
    method used_size (line 2872) | pub fn used_size(&self) -> Vec2 {
    method is_pointer_over_egui (line 2879) | pub fn is_pointer_over_egui(&self) -> bool {
    method is_pointer_over_area (line 2898) | pub fn is_pointer_over_area(&self) -> bool {
    method egui_wants_pointer_input (line 2908) | pub fn egui_wants_pointer_input(&self) -> bool {
    method wants_pointer_input (line 2920) | pub fn wants_pointer_input(&self) -> bool {
    method egui_is_using_pointer (line 2927) | pub fn egui_is_using_pointer(&self) -> bool {
    method is_using_pointer (line 2935) | pub fn is_using_pointer(&self) -> bool {
    method egui_wants_keyboard_input (line 2940) | pub fn egui_wants_keyboard_input(&self) -> bool {
    method wants_keyboard_input (line 2946) | pub fn wants_keyboard_input(&self) -> bool {
    method highlight_widget (line 2956) | pub fn highlight_widget(&self, id: Id) {
    method is_context_menu_open (line 2965) | pub fn is_context_menu_open(&self) -> bool {
    method any_popup_open (line 2975) | pub fn any_popup_open(&self) -> bool {
    method is_popup_open (line 2987) | pub fn is_popup_open(&self) -> bool {
    method pointer_latest_pos (line 3002) | pub fn pointer_latest_pos(&self) -> Option<Pos2> {
    method pointer_hover_pos (line 3008) | pub fn pointer_hover_pos(&self) -> Option<Pos2> {
    method pointer_interact_pos (line 3018) | pub fn pointer_interact_pos(&self) -> Option<Pos2> {
    method multi_touch (line 3023) | pub fn multi_touch(&self) -> Option<MultiTouchInfo> {
    method set_transform_layer (line 3040) | pub fn set_transform_layer(&self, layer_id: LayerId, transform: TSTran...
    method layer_transform_to_global (line 3053) | pub fn layer_transform_to_global(&self, layer_id: LayerId) -> Option<T...
    method layer_transform_from_global (line 3060) | pub fn layer_transform_from_global(&self, layer_id: LayerId) -> Option...
    method transform_layer_shapes (line 3072) | pub fn transform_layer_shapes(&self, layer_id: LayerId, transform: TST...
    method layer_id_at (line 3079) | pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
    method move_to_top (line 3086) | pub fn move_to_top(&self, layer_id: LayerId) {
    method set_sublayer (line 3097) | pub fn set_sublayer(&self, parent: LayerId, child: LayerId) {
    method top_layer_id (line 3102) | pub fn top_layer_id(&self) -> Option<LayerId> {
    method rect_contains_pointer (line 3113) | pub fn rect_contains_pointer(&self, layer_id: LayerId, rect: Rect) -> ...
    method debug_on_hover (line 3143) | pub fn debug_on_hover(&self) -> bool {
    method set_debug_on_hover (line 3149) | pub fn set_debug_on_hover(&self, debug_on_hover: bool) {
    method animate_bool (line 3166) | pub fn animate_bool(&self, id: Id, value: bool) -> f32 {
    method animate_bool_responsive (line 3176) | pub fn animate_bool_responsive(&self, id: Id, value: bool) -> f32 {
    method animate_bool_with_easing (line 3182) | pub fn animate_bool_with_easing(&self, id: Id, value: bool, easing: fn...
    method animate_bool_with_time (line 3189) | pub fn animate_bool_with_time(&self, id: Id, target_value: bool, anima...
    method animate_bool_with_time_and_easing (line 3206) | pub fn animate_bool_with_time_and_easing(
    method animate_value_with_time (line 3239) | pub fn animate_value_with_time(&self, id: Id, target_value: f32, anima...
    method clear_animations (line 3257) | pub fn clear_animations(&self) {
    method settings_ui (line 3264) | pub fn settings_ui(&self, ui: &mut Ui) {
    method fonts_tweak_ui (line 3279) | fn fonts_tweak_ui(&self, ui: &mut Ui) {
    method inspection_ui (line 3299) | pub fn inspection_ui(&self, ui: &mut Ui) {
    method texture_ui (line 3425) | pub fn texture_ui(&self, ui: &mut crate::Ui) {
    method loaders_ui (line 3486) | pub fn loaders_ui(&self, ui: &mut crate::Ui) {
    method memory_ui (line 3553) | pub fn memory_ui(&self, ui: &mut crate::Ui) {
    method style_ui (line 3651) | pub fn style_ui(&self, ui: &mut Ui, theme: Theme) {
    method accesskit_node_builder (line 3669) | pub fn accesskit_node_builder<R>(
    method register_accesskit_parent (line 3677) | pub(crate) fn register_accesskit_parent(&self, id: Id, parent_id: Id) {
    method enable_accesskit (line 3686) | pub fn enable_accesskit(&self) {
    method disable_accesskit (line 3691) | pub fn disable_accesskit(&self) {
    method include_bytes (line 3704) | pub fn include_bytes(&self, uri: impl Into<Cow<'static, str>>, bytes: ...
    method is_loader_installed (line 3710) | pub fn is_loader_installed(&self, id: &str) -> bool {
    method add_bytes_loader (line 3723) | pub fn add_bytes_loader(&self, loader: Arc<dyn load::BytesLoader + Sen...
    method add_image_loader (line 3732) | pub fn add_image_loader(&self, loader: Arc<dyn load::ImageLoader + Sen...
    method add_texture_loader (line 3741) | pub fn add_texture_loader(&self, loader: Arc<dyn load::TextureLoader +...
    method forget_image (line 3749) | pub fn forget_image(&self, uri: &str) {
    method forget_all_images (line 3771) | pub fn forget_all_images(&self) {
    method try_load_bytes (line 3808) | pub fn try_load_bytes(&self, uri: &str) -> load::BytesLoadResult {
    method try_load_image (line 3846) | pub fn try_load_image(&self, uri: &str, size_hint: load::SizeHint) -> ...
    method try_load_texture (line 3891) | pub fn try_load_texture(
    method loaders (line 3914) | pub fn loaders(&self) -> Arc<Loaders> {
    method has_pending_images (line 3919) | pub fn has_pending_images(&self) -> bool {
    method viewport_id (line 3934) | pub fn viewport_id(&self) -> ViewportId {
    method parent_viewport_id (line 3943) | pub fn parent_viewport_id(&self) -> ViewportId {
    method viewport (line 3948) | pub fn viewport<R>(&self, reader: impl FnOnce(&ViewportState) -> R) ->...
    method viewport_for (line 3953) | pub fn viewport_for<R>(
    method set_immediate_viewport_renderer (line 3973) | pub fn set_immediate_viewport_renderer(
    method embed_viewports (line 3986) | pub fn embed_viewports(&self) -> bool {
    method set_embed_viewports (line 3994) | pub fn set_embed_viewports(&self, value: bool) {
    method send_viewport_cmd (line 4001) | pub fn send_viewport_cmd(&self, command: ViewportCommand) {
    method send_viewport_cmd_to (line 4008) | pub fn send_viewport_cmd_to(&self, id: ViewportId, command: ViewportCo...
    method show_viewport_deferred (line 4047) | pub fn show_viewport_deferred(
    method show_viewport_immediate (line 4101) | pub fn show_viewport_immediate<T>(
    method show_embedded_viewport (line 4159) | fn show_embedded_viewport<T>(
    method interaction_snapshot (line 4177) | pub fn interaction_snapshot<R>(&self, reader: impl FnOnce(&Interaction...
    method dragged_id (line 4188) | pub fn dragged_id(&self) -> Option<Id> {
    method is_being_dragged (line 4198) | pub fn is_being_dragged(&self, id: Id) -> bool {
    method drag_started_id (line 4205) | pub fn drag_started_id(&self) -> Option<Id> {
    method drag_stopped_id (line 4210) | pub fn drag_stopped_id(&self) -> Option<Id> {
    method set_dragged_id (line 4215) | pub fn set_dragged_id(&self, id: Id) {
    method stop_dragging (line 4230) | pub fn stop_dragging(&self) {
    method dragging_something_else (line 4247) | pub fn dragging_something_else(&self, not_this: Id) -> bool {
  method default (line 729) | fn default() -> Self {
  function context_impl_send_sync (line 4254) | fn context_impl_send_sync() {
  function warn_if_rect_changes_id (line 4264) | fn warn_if_rect_changes_id(
  function test_single_pass (line 4361) | fn test_single_pass() {
  function test_dual_pass (line 4406) | fn test_dual_pass() {
  function test_multi_pass (line 4472) | fn test_multi_pass() {

FILE: crates/egui/src/data/input.rs
  type RawInput (line 23) | pub struct RawInput {
    method viewport (line 114) | pub fn viewport(&self) -> &ViewportInfo {
    method take (line 122) | pub fn take(&mut self) -> Self {
    method append (line 145) | pub fn append(&mut self, newer: Self) {
    method ui (line 1172) | pub fn ui(&self, ui: &mut crate::Ui) {
  method default (line 92) | fn default() -> Self {
  type ViewportEvent (line 181) | pub enum ViewportEvent {
  type ViewportInfo (line 203) | pub struct ViewportInfo {
    method visible (line 270) | pub fn visible(&self) -> Option<bool> {
    method close_requested (line 286) | pub fn close_requested(&self) -> bool {
    method take (line 291) | pub fn take(&mut self) -> Self {
    method ui (line 308) | pub fn ui(&self, ui: &mut crate::Ui) {
  type HoveredFile (line 395) | pub struct HoveredFile {
  type DroppedFile (line 406) | pub struct DroppedFile {
  type Event (line 428) | pub enum Event {
  type ImeEvent (line 600) | pub enum ImeEvent {
  type PointerButton (line 617) | pub enum PointerButton {
  constant NUM_POINTER_BUTTONS (line 636) | pub const NUM_POINTER_BUTTONS: usize = 5;
  type Modifiers (line 654) | pub struct Modifiers {
    method fmt (line 676) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    constant NONE (line 710) | pub const NONE: Self = Self {
    constant ALT (line 718) | pub const ALT: Self = Self {
    constant CTRL (line 725) | pub const CTRL: Self = Self {
    constant SHIFT (line 732) | pub const SHIFT: Self = Self {
    constant MAC_CMD (line 741) | pub const MAC_CMD: Self = Self {
    constant COMMAND (line 750) | pub const COMMAND: Self = Self {
    method plus (line 774) | pub const fn plus(self, rhs: Self) -> Self {
    method is_none (line 785) | pub fn is_none(&self) -> bool {
    method any (line 790) | pub fn any(&self) -> bool {
    method all (line 795) | pub fn all(&self) -> bool {
    method shift_only (line 801) | pub fn shift_only(&self) -> bool {
    method command_only (line 807) | pub fn command_only(&self) -> bool {
    method matches_logically (line 846) | pub fn matches_logically(&self, pattern: Self) -> bool {
    method matches_exact (line 888) | pub fn matches_exact(&self, pattern: Self) -> bool {
    method matches_any (line 909) | pub fn matches_any(&self, pattern: Self) -> bool {
    method cmd_ctrl_matches (line 935) | pub fn cmd_ctrl_matches(&self, pattern: Self) -> bool {
    method contains (line 980) | pub fn contains(&self, query: Self) -> bool {
    type Output (line 1026) | type Output = Self;
    method bitor (line 1029) | fn bitor(self, rhs: Self) -> Self {
    method bitor_assign (line 1036) | fn bitor_assign(&mut self, rhs: Self) {
    method ui (line 1042) | pub fn ui(&self, ui: &mut crate::Ui) {
  type ModifierNames (line 1053) | pub struct ModifierNames<'a> {
  constant SYMBOLS (line 1068) | pub const SYMBOLS: Self = Self {
  constant NAMES (line 1079) | pub const NAMES: Self = Self {
  function format (line 1091) | pub fn format(&self, modifiers: &Modifiers, is_mac: bool) -> String {
  type KeyboardShortcut (line 1126) | pub struct KeyboardShortcut {
    method new (line 1133) | pub const fn new(modifiers: Modifiers, logical_key: Key) -> Self {
    method format (line 1140) | pub fn format(&self, names: &ModifierNames<'_>, is_mac: bool) -> String {
  function format_kb_shortcut (line 1155) | fn format_kb_shortcut() {
  type TouchDeviceId (line 1228) | pub struct TouchDeviceId(pub u64);
  type TouchId (line 1235) | pub struct TouchId(pub u64);
    method from (line 1273) | fn from(id: u64) -> Self {
    method from (line 1279) | fn from(id: i32) -> Self {
    method from (line 1285) | fn from(id: u32) -> Self {
  type TouchPhase (line 1240) | pub enum TouchPhase {
  type MouseWheelUnit (line 1261) | pub enum MouseWheelUnit {
  type EventFilter (line 1300) | pub struct EventFilter {
    method matches (line 1339) | pub fn matches(&self, event: &Event) -> bool {
  method default (line 1328) | fn default() -> Self {
  type SafeAreaInsets (line 1360) | pub struct SafeAreaInsets(pub MarginF32);
  type Output (line 1363) | type Output = Self;
  method sub (line 1365) | fn sub(self, rhs: SafeAreaInsets) -> Self::Output {

FILE: crates/egui/src/data/key.rs
  type Key (line 7) | pub enum Key {
    constant ALL (line 202) | pub const ALL: &'static [Self] = &[
    method from_name (line 328) | pub fn from_name(key: &str) -> Option<Self> {
    method symbol_or_name (line 452) | pub fn symbol_or_name(self) -> &'static str {
    method name (line 485) | pub fn name(self) -> &'static str {
  function test_key_from_name (line 607) | fn test_key_from_name() {

FILE: crates/egui/src/data/output.rs
  type FullOutput (line 9) | pub struct FullOutput {
    method append (line 40) | pub fn append(&mut self, newer: Self) {
  type IMEOutput (line 74) | pub struct IMEOutput {
  type OutputCommand (line 89) | pub enum OutputCommand {
  type PlatformOutput (line 109) | pub struct PlatformOutput {
    method events_description (line 152) | pub fn events_description(&self) -> String {
    method append (line 170) | pub fn append(&mut self, newer: Self) {
    method take (line 196) | pub fn take(&mut self) -> Self {
    method requested_discard (line 203) | pub fn requested_discard(&self) -> bool {
  type OpenUrl (line 213) | pub struct OpenUrl {
    method same_tab (line 224) | pub fn same_tab(url: impl ToString) -> Self {
    method new_tab (line 232) | pub fn new_tab(url: impl ToString) -> Self {
  type UserAttentionType (line 247) | pub enum UserAttentionType {
  type CursorIcon (line 265) | pub enum CursorIcon {
    constant ALL (line 388) | pub const ALL: [Self; 35] = [
  type OutputEvent (line 432) | pub enum OutputEvent {
    method widget_info (line 453) | pub fn widget_info(&self) -> &WidgetInfo {
    method fmt (line 466) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type WidgetInfo (line 481) | pub struct WidgetInfo {
    method fmt (line 511) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 559) | pub fn new(typ: WidgetType) -> Self {
    method labeled (line 574) | pub fn labeled(typ: WidgetType, enabled: bool, label: impl ToString) -...
    method selected (line 584) | pub fn selected(typ: WidgetType, enabled: bool, selected: bool, label:...
    method drag_value (line 593) | pub fn drag_value(enabled: bool, value: f64) -> Self {
    method slider (line 602) | pub fn slider(enabled: bool, value: f64, label: impl ToString) -> Self {
    method text_edit (line 613) | pub fn text_edit(
    method text_selection_changed (line 637) | pub fn text_selection_changed(
    method description (line 651) | pub fn description(&self) -> String {

FILE: crates/egui/src/data/user_data.rs
  type UserData (line 6) | pub struct UserData {
    method new (line 14) | pub fn new(user_info: impl Any + Send + Sync) -> Self {
    method hash (line 34) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
    method serialize (line 41) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    method deserialize (line 51) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method eq (line 22) | fn eq(&self, other: &Self) -> bool {

FILE: crates/egui/src/debug_text.rs
  function print (line 24) | pub fn print(ctx: &Context, text: impl Into<WidgetText>) {
  type Entry (line 41) | struct Entry {
  type DebugTextPlugin (line 50) | pub struct DebugTextPlugin {
    method paint_entries (line 67) | fn paint_entries(ctx: &Context, entries: Vec<Entry>) {
  method debug_name (line 56) | fn debug_name(&self) -> &'static str {
  method on_end_pass (line 60) | fn on_end_pass(&mut self, ui: &mut Ui) {

FILE: crates/egui/src/drag_and_drop.rs
  type DragAndDrop (line 22) | pub struct DragAndDrop {
    method set_payload (line 78) | pub fn set_payload<Payload>(ctx: &Context, payload: Payload)
    method clear_payload (line 86) | pub fn clear_payload(ctx: &Context) {
    method payload (line 96) | pub fn payload<Payload>(ctx: &Context) -> Option<Arc<Payload>>
    method take_payload (line 111) | pub fn take_payload<Payload>(ctx: &Context) -> Option<Arc<Payload>>
    method has_payload_of_type (line 122) | pub fn has_payload_of_type<Payload>(ctx: &Context) -> bool
    method has_any_payload (line 133) | pub fn has_any_payload(ctx: &Context) -> bool {
  method debug_name (line 28) | fn debug_name(&self) -> &'static str {
  method on_begin_pass (line 35) | fn on_begin_pass(&mut self, ui: &mut Ui) {
  method on_end_pass (line 53) | fn on_end_pass(&mut self, ui: &mut Ui) {

FILE: crates/egui/src/grid.rs
  type State (line 14) | pub(crate) struct State {
    method load (line 20) | pub fn load(ctx: &Context, id: Id) -> Option<Self> {
    method store (line 24) | pub fn store(self, ctx: &Context, id: Id) {
    method set_min_col_width (line 31) | fn set_min_col_width(&mut self, col: usize, width: f32) {
    method set_min_row_height (line 37) | fn set_min_row_height(&mut self, row: usize, height: f32) {
    method col_width (line 43) | fn col_width(&self, col: usize) -> Option<f32> {
    method row_height (line 47) | fn row_height(&self, row: usize) -> Option<f32> {
    method full_width (line 51) | fn full_width(&self, x_spacing: f32) -> f32 {
  type ColorPickerFn (line 60) | type ColorPickerFn = Box<dyn Send + Sync + Fn(usize, &Style) -> Option<C...
  type GridLayout (line 62) | pub(crate) struct GridLayout {
    method new (line 91) | pub(crate) fn new(ui: &Ui, id: Id, prev_state: Option<State>) -> Self {
    method prev_col_width (line 127) | fn prev_col_width(&self, col: usize) -> f32 {
    method prev_row_height (line 133) | fn prev_row_height(&self, row: usize) -> f32 {
    method wrap_text (line 139) | pub(crate) fn wrap_text(&self) -> bool {
    method available_rect (line 143) | pub(crate) fn available_rect(&self, region: &Region) -> Rect {
    method next_cell (line 182) | pub(crate) fn next_cell(&self, cursor: Rect, child_size: Vec2) -> Rect {
    method align_size_within_rect (line 190) | pub(crate) fn align_size_within_rect(&self, size: Vec2, frame: Rect) -...
    method justify_and_align (line 197) | pub(crate) fn justify_and_align(&self, frame: Rect, size: Vec2) -> Rect {
    method advance (line 201) | pub(crate) fn advance(&mut self, cursor: &mut Rect, _frame_rect: Rect,...
    method paint_row (line 241) | fn paint_row(&self, cursor: &Rect, painter: &Painter) {
    method end_row (line 261) | pub(crate) fn end_row(&mut self, cursor: &mut Rect, painter: &Painter) {
    method save (line 275) | pub(crate) fn save(&self) {
  type Grid (line 314) | pub struct Grid {
    method new (line 327) | pub fn new(id_salt: impl std::hash::Hash) -> Self {
    method with_row_color (line 342) | pub fn with_row_color<F>(mut self, color_picker: F) -> Self
    method num_columns (line 352) | pub fn num_columns(mut self, num_columns: usize) -> Self {
    method striped (line 361) | pub fn striped(self, striped: bool) -> Self {
    method min_col_width (line 375) | pub fn min_col_width(mut self, min_col_width: f32) -> Self {
    method min_row_height (line 383) | pub fn min_row_height(mut self, min_row_height: f32) -> Self {
    method max_col_width (line 390) | pub fn max_col_width(mut self, max_col_width: f32) -> Self {
    method spacing (line 398) | pub fn spacing(mut self, spacing: impl Into<Vec2>) -> Self {
    method start_row (line 406) | pub fn start_row(mut self, start_row: usize) -> Self {
    method show (line 413) | pub fn show<R>(self, ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -...
    method show_dyn (line 417) | fn show_dyn<'c, R>(
  function striped_row_color (line 491) | fn striped_row_color(row: usize, style: &Style) -> Option<Color32> {

FILE: crates/egui/src/gui_zoom.rs
  constant ZOOM_IN (line 10) | pub const ZOOM_IN: KeyboardShortcut = KeyboardShortcut::new(Modifiers::C...
  constant ZOOM_IN_SECONDARY (line 18) | pub const ZOOM_IN_SECONDARY: KeyboardShortcut =
  constant ZOOM_OUT (line 22) | pub const ZOOM_OUT: KeyboardShortcut = KeyboardShortcut::new(Modifiers::...
  constant ZOOM_RESET (line 25) | pub const ZOOM_RESET: KeyboardShortcut = KeyboardShortcut::new(Modifiers...
  function zoom_with_keyboard (line 33) | pub(crate) fn zoom_with_keyboard(ctx: &Context) {
  constant MIN_ZOOM_FACTOR (line 48) | const MIN_ZOOM_FACTOR: f32 = 0.2;
  constant MAX_ZOOM_FACTOR (line 49) | const MAX_ZOOM_FACTOR: f32 = 5.0;
  function zoom_in (line 52) | pub fn zoom_in(ctx: &Context) {
  function zoom_out (line 61) | pub fn zoom_out(ctx: &Context) {
  function zoom_menu_buttons (line 72) | pub fn zoom_menu_buttons(ui: &mut Ui) {

FILE: crates/egui/src/hit_test.rs
  type WidgetHits (line 14) | pub struct WidgetHits {
  function hit_test (line 42) | pub fn hit_test(
  function contains_circle (line 199) | fn contains_circle(interact_rect: emath::Rect, pos: Pos2, radius: f32) -...
  function hit_test_on_close (line 203) | fn hit_test_on_close(close: &[WidgetRect], pos: Pos2) -> WidgetHits {
  function find_closest (line 412) | fn find_closest(widgets: impl Iterator<Item = WidgetRect>, pos: Pos2) ->...
  function find_closest_within (line 416) | fn find_closest_within(
  function wr (line 450) | fn wr(id: Id, sense: Sense, rect: Rect) -> WidgetRect {
  function buttons_on_window (line 462) | fn buttons_on_window() {
  function thin_resize_handle_next_to_label (line 503) | fn thin_resize_handle_next_to_label() {

FILE: crates/egui/src/id.rs
  type Id (line 34) | pub struct Id(NonZeroU64);
    constant NULL (line 44) | pub const NULL: Self = Self(NonZeroU64::MAX);
    method from_hash (line 47) | const fn from_hash(hash: u64) -> Self {
    method new (line 56) | pub fn new(source: impl std::hash::Hash) -> Self {
    method with (line 61) | pub fn with(self, child: impl std::hash::Hash) -> Self {
    method short_debug_format (line 70) | pub fn short_debug_format(&self) -> String {
    method value (line 78) | pub fn value(&self) -> u64 {
    method accesskit_id (line 82) | pub fn accesskit_id(&self) -> accesskit::NodeId {
    method from_high_entropy_bits (line 101) | pub unsafe fn from_high_entropy_bits(value: u64) -> Self {
    method fmt (line 107) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method from (line 115) | fn from(string: &'static str) -> Self {
    method from (line 122) | fn from(string: String) -> Self {
  function id_size (line 128) | fn id_size() {
  type IdSet (line 136) | pub type IdSet = nohash_hasher::IntSet<Id>;
  type IdMap (line 139) | pub type IdMap<V> = nohash_hasher::IntMap<Id, V>;

FILE: crates/egui/src/input_state/mod.rs
  type SurrenderFocusOn (line 27) | pub enum SurrenderFocusOn {
    method ui (line 40) | pub fn ui(&mut self, ui: &mut crate::Ui) {
  type InputOptions (line 59) | pub struct InputOptions {
    method ui (line 128) | pub fn ui(&mut self, ui: &mut crate::Ui) {
  method default (line 103) | fn default() -> Self {
  type InputState (line 215) | pub struct InputState {
    method begin_pass (line 367) | pub fn begin_pass(
    method viewport (line 495) | pub fn viewport(&self) -> &ViewportInfo {
    method content_rect (line 507) | pub fn content_rect(&self) -> Rect {
    method viewport_rect (line 521) | pub fn viewport_rect(&self) -> Rect {
    method screen_rect (line 529) | pub fn screen_rect(&self) -> Rect {
    method safe_area_insets (line 539) | pub fn safe_area_insets(&self) -> SafeAreaInsets {
    method smooth_scroll_delta (line 555) | pub fn smooth_scroll_delta(&self) -> Vec2 {
    method zoom_delta (line 567) | pub fn zoom_delta(&self) -> f32 {
    method zoom_delta_2d (line 590) | pub fn zoom_delta_2d(&self) -> Vec2 {
    method rotation_delta (line 622) | pub fn rotation_delta(&self) -> f32 {
    method translation_delta (line 635) | pub fn translation_delta(&self) -> Vec2 {
    method is_scrolling (line 643) | pub fn is_scrolling(&self) -> bool {
    method time_since_last_scroll (line 649) | pub fn time_since_last_scroll(&self) -> f32 {
    method wants_repaint_after (line 660) | pub(crate) fn wants_repaint_after(&self) -> Option<Duration> {
    method count_and_consume_key (line 696) | pub fn count_and_consume_key(&mut self, modifiers: Modifiers, logical_...
    method consume_key (line 727) | pub fn consume_key(&mut self, modifiers: Modifiers, logical_key: Key) ...
    method consume_shortcut (line 740) | pub fn consume_shortcut(&mut self, shortcut: &KeyboardShortcut) -> bool {
    method key_pressed (line 751) | pub fn key_pressed(&self, desired_key: Key) -> bool {
    method num_presses (line 758) | pub fn num_presses(&self, desired_key: Key) -> usize {
    method key_down (line 774) | pub fn key_down(&self, desired_key: Key) -> bool {
    method key_released (line 779) | pub fn key_released(&self, desired_key: Key) -> bool {
    method pixels_per_point (line 794) | pub fn pixels_per_point(&self) -> f32 {
    method physical_pixel_size (line 800) | pub fn physical_pixel_size(&self) -> f32 {
    method aim_radius (line 807) | pub fn aim_radius(&self) -> f32 {
    method multi_touch (line 839) | pub fn multi_touch(&self) -> Option<MultiTouchInfo> {
    method any_touches (line 845) | pub fn any_touches(&self) -> bool {
    method has_touch_screen (line 850) | pub fn has_touch_screen(&self) -> bool {
    method create_touch_states_for_new_devices (line 856) | fn create_touch_states_for_new_devices(&mut self, events: &[Event]) {
    method accesskit_action_requests (line 866) | pub fn accesskit_action_requests(
    method consume_accesskit_action_requests (line 884) | pub fn consume_accesskit_action_requests(
    method has_accesskit_action_request (line 901) | pub fn has_accesskit_action_request(&self, id: crate::Id, action: acce...
    method num_accesskit_action_requests (line 905) | pub fn num_accesskit_action_requests(&self, id: crate::Id, action: acc...
    method filtered_events (line 910) | pub fn filtered_events(&self, filter: &EventFilter) -> Vec<Event> {
    method is_long_touch (line 922) | pub(crate) fn is_long_touch(&self) -> bool {
    method ui (line 1572) | pub fn ui(&self, ui: &mut crate::Ui) {
  method default (line 337) | fn default() -> Self {
  type Click (line 932) | pub(crate) struct Click {
    method is_double (line 943) | pub fn is_double(&self) -> bool {
    method is_triple (line 947) | pub fn is_triple(&self) -> bool {
  type PointerEvent (line 954) | pub(crate) enum PointerEvent {
    method is_press (line 967) | pub fn is_press(&self) -> bool {
    method is_release (line 971) | pub fn is_release(&self) -> bool {
    method is_click (line 975) | pub fn is_click(&self) -> bool {
  type PointerState (line 992) | pub struct PointerState {
    method begin_pass (line 1102) | pub(crate) fn begin_pass(mut self, time: f64, new: &RawInput, options:...
    method wants_repaint (line 1258) | fn wants_repaint(&self) -> bool {
    method delta (line 1264) | pub fn delta(&self) -> Vec2 {
    method motion (line 1272) | pub fn motion(&self) -> Option<Vec2> {
    method velocity (line 1281) | pub fn velocity(&self) -> Vec2 {
    method direction (line 1289) | pub fn direction(&self) -> Vec2 {
    method press_origin (line 1296) | pub fn press_origin(&self) -> Option<Pos2> {
    method total_drag_delta (line 1301) | pub fn total_drag_delta(&self) -> Option<Vec2> {
    method press_start_time (line 1308) | pub fn press_start_time(&self) -> Option<f64> {
    method latest_pos (line 1315) | pub fn latest_pos(&self) -> Option<Pos2> {
    method hover_pos (line 1321) | pub fn hover_pos(&self) -> Option<Pos2> {
    method interact_pos (line 1331) | pub fn interact_pos(&self) -> Option<Pos2> {
    method has_pointer (line 1339) | pub fn has_pointer(&self) -> bool {
    method is_still (line 1346) | pub fn is_still(&self) -> bool {
    method is_moving (line 1353) | pub fn is_moving(&self) -> bool {
    method time_since_last_movement (line 1359) | pub fn time_since_last_movement(&self) -> f32 {
    method time_since_last_click (line 1365) | pub fn time_since_last_click(&self) -> f32 {
    method any_pressed (line 1373) | pub fn any_pressed(&self) -> bool {
    method any_released (line 1378) | pub fn any_released(&self) -> bool {
    method button_pressed (line 1383) | pub fn button_pressed(&self, button: PointerButton) -> bool {
    method button_released (line 1390) | pub fn button_released(&self, button: PointerButton) -> bool {
    method primary_pressed (line 1397) | pub fn primary_pressed(&self) -> bool {
    method secondary_pressed (line 1402) | pub fn secondary_pressed(&self) -> bool {
    method primary_released (line 1407) | pub fn primary_released(&self) -> bool {
    method secondary_released (line 1412) | pub fn secondary_released(&self) -> bool {
    method any_down (line 1419) | pub fn any_down(&self) -> bool {
    method any_click (line 1424) | pub fn any_click(&self) -> bool {
    method button_clicked (line 1431) | pub fn button_clicked(&self, button: PointerButton) -> bool {
    method button_double_clicked (line 1438) | pub fn button_double_clicked(&self, button: PointerButton) -> bool {
    method button_triple_clicked (line 1451) | pub fn button_triple_clicked(&self, button: PointerButton) -> bool {
    method primary_clicked (line 1464) | pub fn primary_clicked(&self) -> bool {
    method secondary_clicked (line 1469) | pub fn secondary_clicked(&self) -> bool {
    method button_down (line 1477) | pub fn button_down(&self, button: PointerButton) -> bool {
    method could_any_button_be_click (line 1484) | pub fn could_any_button_be_click(&self) -> bool {
    method is_decidedly_dragging (line 1511) | pub fn is_decidedly_dragging(&self) -> bool {
    method is_long_press (line 1522) | pub(crate) fn is_long_press(&self) -> bool {
    method primary_down (line 1535) | pub fn primary_down(&self) -> bool {
    method secondary_down (line 1543) | pub fn secondary_down(&self) -> bool {
    method middle_down (line 1551) | pub fn middle_down(&self) -> bool {
    method is_moving_towards_rect (line 1556) | pub fn is_moving_towards_rect(&self, rect: &Rect) -> bool {
    method ui (line 1651) | pub fn ui(&self, ui: &mut crate::Ui) {
  method default (line 1075) | fn default() -> Self {

FILE: crates/egui/src/input_state/touch_state.rs
  type MultiTouchInfo (line 11) | pub struct MultiTouchInfo {
  type TouchState (line 71) | pub(crate) struct TouchState {
    method new (line 132) | pub fn new(device_id: TouchDeviceId) -> Self {
    method begin_pass (line 140) | pub fn begin_pass(&mut self, time: f64, new: &RawInput, pointer_pos: O...
    method any_touches (line 184) | pub fn any_touches(&self) -> bool {
    method info (line 188) | pub fn info(&self) -> Option<MultiTouchInfo> {
    method update_gesture (line 225) | fn update_gesture(&mut self, time: f64, pointer_pos: Option<Pos2>) {
    method calc_dynamic_state (line 248) | fn calc_dynamic_state(&self) -> Option<DynGestureState> {
    method ui (line 301) | pub fn ui(&self, ui: &mut crate::Ui) {
  type GestureState (line 91) | struct GestureState {
  type DynGestureState (line 102) | struct DynGestureState {
  type ActiveTouch (line 120) | struct ActiveTouch {
  method fmt (line 308) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type PinchType (line 319) | enum PinchType {
    method classify (line 326) | fn classify(touches: &BTreeMap<TouchId, ActiveTouch>) -> Self {

FILE: crates/egui/src/input_state/wheel_state.rs
  type Status (line 26) | pub enum Status {
  type WheelState (line 39) | pub struct WheelState {
    method on_wheel_event (line 84) | pub fn on_wheel_event(
    method after_events (line 161) | pub fn after_events(&mut self, time: f64, dt: f32) {
    method is_scrolling (line 194) | pub fn is_scrolling(&self) -> bool {
    method ui (line 198) | pub fn ui(&self, ui: &mut crate::Ui) {
  method default (line 71) | fn default() -> Self {

FILE: crates/egui/src/interaction.rs
  type InteractionSnapshot (line 13) | pub struct InteractionSnapshot {
    method ui (line 60) | pub fn ui(&self, ui: &mut crate::Ui) {
  function interact (line 109) | pub(crate) fn interact(

FILE: crates/egui/src/introspection.rs
  function font_family_ui (line 7) | pub fn font_family_ui(ui: &mut Ui, font_family: &mut FontFamily) {
  function font_id_ui (line 17) | pub fn font_id_ui(ui: &mut Ui, font_id: &mut FontId) {
  function font_texture_ui (line 29) | pub(crate) fn font_texture_ui(ui: &mut Ui, [width, height]: [usize; 2]) ...
  method ui (line 78) | fn ui(self, ui: &mut Ui) -> Response {
  function label (line 134) | fn label(ui: &mut Ui, alloc_info: &epaint::stats::AllocInfo, what: &str)...
  method ui (line 139) | fn ui(self, ui: &mut Ui) -> Response {
  method ui (line 211) | fn ui(self, ui: &mut Ui) -> Response {

FILE: crates/egui/src/layers.rs
  type Order (line 10) | pub enum Order {
    constant COUNT (line 30) | const COUNT: usize = 5;
    constant ALL (line 31) | const ALL: [Self; Self::COUNT] = [
    constant TOP (line 38) | pub const TOP: Self = Self::Debug;
    method allow_interaction (line 41) | pub fn allow_interaction(&self) -> bool {
    method short_debug_format (line 50) | pub fn short_debug_format(&self) -> &'static str {
  type LayerId (line 65) | pub struct LayerId {
    method new (line 71) | pub fn new(order: Order, id: Id) -> Self {
    method debug (line 75) | pub fn debug() -> Self {
    method background (line 82) | pub fn background() -> Self {
    method allow_interaction (line 91) | pub fn allow_interaction(&self) -> bool {
    method short_debug_format (line 96) | pub fn short_debug_format(&self) -> String {
    method fmt (line 106) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type ShapeIdx (line 115) | pub struct ShapeIdx(pub usize);
  type PaintList (line 119) | pub struct PaintList(Vec<ClippedShape>);
    method is_empty (line 123) | pub fn is_empty(&self) -> bool {
    method next_idx (line 127) | pub fn next_idx(&self) -> ShapeIdx {
    method add (line 133) | pub fn add(&mut self, clip_rect: Rect, shape: Shape) -> ShapeIdx {
    method extend (line 139) | pub fn extend<I: IntoIterator<Item = Shape>>(&mut self, clip_rect: Rec...
    method set (line 155) | pub fn set(&mut self, idx: ShapeIdx, clip_rect: Rect, shape: Shape) {
    method reset_shape (line 166) | pub fn reset_shape(&mut self, idx: ShapeIdx) {
    method mutate_shape (line 171) | pub fn mutate_shape(&mut self, idx: ShapeIdx, f: impl FnOnce(&mut Clip...
    method transform (line 176) | pub fn transform(&mut self, transform: TSTransform) {
    method transform_range (line 184) | pub fn transform_range(&mut self, start: ShapeIdx, end: ShapeIdx, tran...
    method all_entries (line 192) | pub fn all_entries(&self) -> impl ExactSizeIterator<Item = &ClippedSha...
  type GraphicLayers (line 199) | pub struct GraphicLayers([IdMap<PaintList>; Order::COUNT]);
    method entry (line 203) | pub fn entry(&mut self, layer_id: LayerId) -> &mut PaintList {
    method get (line 210) | pub fn get(&self, layer_id: LayerId) -> Option<&PaintList> {
    method get_mut (line 215) | pub fn get_mut(&mut self, layer_id: LayerId) -> Option<&mut PaintList> {
    method drain (line 219) | pub fn drain(

FILE: crates/egui/src/layout.rs
  constant INFINITY (line 7) | const INFINITY: f32 = f32::INFINITY;
  type Region (line 14) | pub(crate) struct Region {
    method expand_to_include_rect (line 52) | pub fn expand_to_include_rect(&mut self, rect: Rect) {
    method expand_to_include_x (line 59) | pub fn expand_to_include_x(&mut self, x: f32) {
    method expand_to_include_y (line 67) | pub fn expand_to_include_y(&mut self, y: f32) {
    method sanity_check (line 73) | pub fn sanity_check(&self) {
  type Direction (line 93) | pub enum Direction {
    method is_horizontal (line 102) | pub fn is_horizontal(self) -> bool {
    method is_vertical (line 110) | pub fn is_vertical(self) -> bool {
  type Layout (line 132) | pub struct Layout {
    method left_to_right (line 171) | pub fn left_to_right(valign: Align) -> Self {
    method right_to_left (line 186) | pub fn right_to_left(valign: Align) -> Self {
    method top_down (line 201) | pub fn top_down(halign: Align) -> Self {
    method top_down_justified (line 214) | pub fn top_down_justified(halign: Align) -> Self {
    method bottom_up (line 222) | pub fn bottom_up(halign: Align) -> Self {
    method from_main_dir_and_cross_align (line 234) | pub fn from_main_dir_and_cross_align(main_dir: Direction, cross_align:...
    method centered_and_justified (line 250) | pub fn centered_and_justified(main_dir: Direction) -> Self {
    method with_main_wrap (line 266) | pub fn with_main_wrap(self, main_wrap: bool) -> Self {
    method with_main_align (line 272) | pub fn with_main_align(self, main_align: Align) -> Self {
    method with_cross_align (line 281) | pub fn with_cross_align(self, cross_align: Align) -> Self {
    method with_main_justify (line 292) | pub fn with_main_justify(self, main_justify: bool) -> Self {
    method with_cross_justify (line 306) | pub fn with_cross_justify(self, cross_justify: bool) -> Self {
    method main_dir (line 317) | pub fn main_dir(&self) -> Direction {
    method main_wrap (line 322) | pub fn main_wrap(&self) -> bool {
    method cross_align (line 327) | pub fn cross_align(&self) -> Align {
    method cross_justify (line 332) | pub fn cross_justify(&self) -> bool {
    method is_horizontal (line 337) | pub fn is_horizontal(&self) -> bool {
    method is_vertical (line 342) | pub fn is_vertical(&self) -> bool {
    method prefer_right_to_left (line 346) | pub fn prefer_right_to_left(&self) -> bool {
    method horizontal_placement (line 354) | pub fn horizontal_placement(&self) -> Align {
    method horizontal_align (line 363) | pub fn horizontal_align(&self) -> Align {
    method vertical_align (line 372) | pub fn vertical_align(&self) -> Align {
    method align2 (line 381) | fn align2(&self) -> Align2 {
    method horizontal_justify (line 385) | pub fn horizontal_justify(&self) -> bool {
    method vertical_justify (line 393) | pub fn vertical_justify(&self) -> bool {
    method align_size_within_rect (line 404) | pub fn align_size_within_rect(&self, size: Vec2, outer: Rect) -> Rect {
    method initial_cursor (line 410) | fn initial_cursor(&self, max_rect: Rect) -> Rect {
    method region_from_max_rect (line 431) | pub(crate) fn region_from_max_rect(&self, max_rect: Rect) -> Region {
    method available_rect_before_wrap (line 443) | pub(crate) fn available_rect_before_wrap(&self, region: &Region) -> Re...
    method available_size (line 449) | pub(crate) fn available_size(&self, r: &Region) -> Vec2 {
    method available_from_cursor_max_rect (line 464) | fn available_from_cursor_max_rect(&self, cursor: Rect, max_rect: Rect)...
    method next_frame (line 529) | pub(crate) fn next_frame(&self, region: &Region, child_size: Vec2, spa...
    method next_frame_ignore_wrap (line 612) | fn next_frame_ignore_wrap(&self, region: &Region, child_size: Vec2) ->...
    method justify_and_align (line 657) | pub(crate) fn justify_and_align(&self, frame: Rect, mut child_size: Ve...
    method next_widget_space_ignore_wrap_justify (line 673) | pub(crate) fn next_widget_space_ignore_wrap_justify(
    method next_widget_position (line 686) | pub(crate) fn next_widget_position(&self, region: &Region) -> Pos2 {
    method advance_cursor (line 692) | pub(crate) fn advance_cursor(&self, region: &mut Region, amount: f32) {
    method advance_after_rects (line 717) | pub(crate) fn advance_after_rects(
    method end_row (line 787) | pub(crate) fn end_row(&self, region: &mut Region, spacing: Vec2) {
    method set_row_height (line 810) | pub(crate) fn set_row_height(&self, region: &mut Region, height: f32) {
    method paint_text_at_cursor (line 823) | pub(crate) fn paint_text_at_cursor(
  method default (line 159) | fn default() -> Self {

FILE: crates/egui/src/lib.rs
  type Rounding (line 503) | pub type Rounding = CornerRadius;
  function warn_if_debug_build (line 508) | pub fn warn_if_debug_build(ui: &mut crate::Ui) {
  constant MINUS_CHAR_STR (line 583) | pub(crate) const MINUS_CHAR_STR: &str = "−";
  constant OS_LINUX (line 606) | pub const OS_LINUX: char = '🐧';
  constant OS_WINDOWS (line 609) | pub const OS_WINDOWS: char = '';
  constant OS_ANDROID (line 612) | pub const OS_ANDROID: char = '';
  constant OS_APPLE (line 615) | pub const OS_APPLE: char = '';
  constant GITHUB (line 618) | pub const GITHUB: char = '';
  constant GIT (line 621) | pub const GIT: char = '';
  type WidgetType (line 629) | pub enum WidgetType {
  function __run_test_ctx (line 679) | pub fn __run_test_ctx(mut run_ui: impl FnMut(&Context)) {
  function __run_test_ui (line 688) | pub fn __run_test_ui(mut add_contents: impl FnMut(&mut Ui)) {
  function accesskit_root_id (line 696) | pub fn accesskit_root_id() -> Id {

FILE: crates/egui/src/load.rs
  type LoadError (line 76) | pub enum LoadError {
    method byte_size (line 104) | pub fn byte_size(&self) -> usize {
  method fmt (line 117) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Result (line 141) | pub type Result<T, E = LoadError> = std::result::Result<T, E>;
  type SizeHint (line 148) | pub enum SizeHint {
    method scale_by (line 177) | pub fn scale_by(self, factor: f32) -> Self {
  method default (line 197) | fn default() -> Self {
  type Bytes (line 206) | pub enum Bytes {
    method from (line 222) | fn from(value: &'static [u8]) -> Self {
    method from (line 229) | fn from(value: &'static [u8; N]) -> Self {
    method from (line 236) | fn from(value: Arc<[u8]>) -> Self {
    method from (line 243) | fn from(value: Vec<u8>) -> Self {
    method as_ref (line 250) | fn as_ref(&self) -> &[u8] {
  method fmt (line 212) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Target (line 259) | type Target = [u8];
  method deref (line 262) | fn deref(&self) -> &Self::Target {
  type BytesPoll (line 273) | pub enum BytesPoll {
  type BytesLoadResult (line 310) | pub type BytesLoadResult = Result<BytesPoll>;
  type BytesLoader (line 319) | pub trait BytesLoader {
    method id (line 323) | fn id(&self) -> &str;
    method load (line 337) | fn load(&self, ctx: &Context, uri: &str) -> BytesLoadResult;
    method forget (line 343) | fn forget(&self, uri: &str);
    method forget_all (line 349) | fn forget_all(&self);
    method end_pass (line 353) | fn end_pass(&self, pass_index: u64) {
    method byte_size (line 358) | fn byte_size(&self) -> usize;
    method has_pending (line 361) | fn has_pending(&self) -> bool {
  type ImagePoll (line 372) | pub enum ImagePoll {
  type ImageLoadResult (line 385) | pub type ImageLoadResult = Result<ImagePoll>;
  type ImageLoader (line 390) | pub trait ImageLoader: std::any::Any {
    method id (line 397) | fn id(&self) -> &str;
    method load (line 411) | fn load(&self, ctx: &Context, uri: &str, size_hint: SizeHint) -> Image...
    method forget (line 417) | fn forget(&self, uri: &str);
    method forget_all (line 423) | fn forget_all(&self);
    method end_pass (line 427) | fn end_pass(&self, pass_index: u64) {
    method byte_size (line 432) | fn byte_size(&self) -> usize;
    method has_pending (line 437) | fn has_pending(&self) -> bool {
  type SizedTexture (line 444) | pub struct SizedTexture {
    method new (line 453) | pub fn new(id: impl Into<TextureId>, size: impl Into<Vec2>) -> Self {
    method from_handle (line 461) | pub fn from_handle(handle: &TextureHandle) -> Self {
    method from (line 472) | fn from((id, size): (TextureId, Vec2)) -> Self {
    method from (line 479) | fn from(handle: &'a TextureHandle) -> Self {
  type TexturePoll (line 490) | pub enum TexturePoll {
    method size (line 506) | pub fn size(&self) -> Option<Vec2> {
    method texture_id (line 514) | pub fn texture_id(&self) -> Option<TextureId> {
    method is_pending (line 522) | pub fn is_pending(&self) -> bool {
    method is_ready (line 527) | pub fn is_ready(&self) -> bool {
  type TextureLoadResult (line 532) | pub type TextureLoadResult = Result<TexturePoll>;
  type TextureLoader (line 544) | pub trait TextureLoader {
    method id (line 551) | fn id(&self) -> &str;
    method load (line 565) | fn load(
    method forget (line 577) | fn forget(&self, uri: &str);
    method forget_all (line 583) | fn forget_all(&self);
    method end_pass (line 587) | fn end_pass(&self, pass_index: u64) {
    method byte_size (line 592) | fn byte_size(&self) -> usize;
  type BytesLoaderImpl (line 595) | type BytesLoaderImpl = Arc<dyn BytesLoader + Send + Sync + 'static>;
  type ImageLoaderImpl (line 596) | type ImageLoaderImpl = Arc<dyn ImageLoader + Send + Sync + 'static>;
  type TextureLoaderImpl (line 597) | type TextureLoaderImpl = Arc<dyn TextureLoader + Send + Sync + 'static>;
  type Loaders (line 601) | pub struct Loaders {
    method end_pass (line 623) | pub fn end_pass(&self, pass_index: u64) {
  method default (line 609) | fn default() -> Self {

FILE: crates/egui/src/load/bytes_loader.rs
  type DefaultBytesLoader (line 10) | pub struct DefaultBytesLoader {
    method insert (line 15) | pub fn insert(&self, uri: impl Into<Cow<'static, str>>, bytes: impl In...
  method id (line 30) | fn id(&self) -> &'static str {
  method load (line 34) | fn load(&self, _: &Context, uri: &str) -> BytesLoadResult {
  method forget (line 54) | fn forget(&self, uri: &str) {
  method forget_all (line 60) | fn forget_all(&self) {
  method byte_size (line 66) | fn byte_size(&self) -> usize {

FILE: crates/egui/src/load/texture_loader.rs
  type PrimaryKey (line 11) | struct PrimaryKey {
  type Bucket (line 17) | type Bucket = HashMap<Option<SizeHint>, Entry>;
  type Entry (line 19) | struct Entry {
  type DefaultTextureLoader (line 29) | pub struct DefaultTextureLoader {
  method id (line 35) | fn id(&self) -> &'static str {
  method load (line 39) | fn load(
  method forget (line 104) | fn forget(&self, uri: &str) {
  method forget_all (line 110) | fn forget_all(&self) {
  method end_pass (line 116) | fn end_pass(&self, pass_index: u64) {
  method byte_size (line 131) | fn byte_size(&self) -> usize {
  function is_svg (line 145) | fn is_svg(uri: &str) -> bool {

FILE: crates/egui/src/memory/mod.rs
  type Memory (line 30) | pub struct Memory {
    method begin_pass (line 752) | pub(crate) fn begin_pass(&mut self, new_raw_input: &RawInput, viewport...
    method end_pass (line 774) | pub(crate) fn end_pass(&mut self, used_ids: &IdMap<Rect>) {
    method set_viewport_id (line 789) | pub(crate) fn set_viewport_id(&mut self, viewport_id: ViewportId) {
    method areas (line 794) | pub fn areas(&self) -> &Areas {
    method areas_mut (line 801) | pub fn areas_mut(&mut self) -> &mut Areas {
    method layer_id_at (line 806) | pub fn layer_id_at(&self, pos: Pos2) -> Option<LayerId> {
    method layer_transforms (line 817) | pub fn layer_transforms(&self, layer_id: LayerId) -> Option<TSTransfor...
    method layer_ids (line 822) | pub fn layer_ids(&self) -> impl ExactSizeIterator<Item = LayerId> + '_ {
    method had_focus_last_frame (line 828) | pub fn had_focus_last_frame(&self, id: Id) -> bool {
    method lost_focus (line 834) | pub(crate) fn lost_focus(&self, id: Id) -> bool {
    method gained_focus (line 840) | pub(crate) fn gained_focus(&self, id: Id) -> bool {
    method has_focus (line 851) | pub fn has_focus(&self, id: Id) -> bool {
    method focused (line 856) | pub fn focused(&self) -> Option<Id> {
    method set_focus_lock_filter (line 866) | pub fn set_focus_lock_filter(&mut self, id: Id, event_filter: EventFil...
    method request_focus (line 879) | pub fn request_focus(&mut self, id: Id) {
    method surrender_focus (line 886) | pub fn surrender_focus(&mut self, id: Id) {
    method move_focus (line 894) | pub fn move_focus(&mut self, direction: FocusDirection) {
    method is_above_modal_layer (line 901) | pub fn is_above_modal_layer(&self, layer_id: LayerId) -> bool {
    method allows_interaction (line 916) | pub fn allows_interaction(&self, layer_id: LayerId) -> bool {
    method interested_in_focus (line 932) | pub fn interested_in_focus(&mut self, id: Id, layer_id: LayerId) {
    method set_modal_layer (line 941) | pub fn set_modal_layer(&mut self, layer_id: LayerId) {
    method top_modal_layer (line 955) | pub fn top_modal_layer(&self) -> Option<LayerId> {
    method stop_text_input (line 961) | pub fn stop_text_input(&mut self) {
    method reset_areas (line 967) | pub fn reset_areas(&mut self) {
    method area_rect (line 975) | pub fn area_rect(&self, id: impl Into<Id>) -> Option<Rect> {
    method interaction (line 979) | pub(crate) fn interaction(&self) -> &InteractionState {
    method interaction_mut (line 985) | pub(crate) fn interaction_mut(&mut self) -> &mut InteractionState {
    method focus (line 989) | pub(crate) fn focus(&self) -> Option<&Focus> {
    method focus_mut (line 993) | pub(crate) fn focus_mut(&mut self) -> &mut Focus {
    method is_popup_open (line 1027) | pub fn is_popup_open(&self, popup_id: Id) -> bool {
    method any_popup_open (line 1036) | pub fn any_popup_open(&self) -> bool {
    method open_popup (line 1044) | pub fn open_popup(&mut self, popup_id: Id) {
    method keep_popup_open (line 1055) | pub fn keep_popup_open(&mut self, popup_id: Id) {
    method open_popup_at (line 1065) | pub fn open_popup_at(&mut self, popup_id: Id, pos: impl Into<Option<Po...
    method popup_position (line 1072) | pub fn popup_position(&self, id: Id) -> Option<Pos2> {
    method close_all_popups (line 1079) | pub fn close_all_popups(&mut self) {
    method close_popup (line 1087) | pub fn close_popup(&mut self, popup_id: Id) {
    method toggle_popup (line 1098) | pub fn toggle_popup(&mut self, popup_id: Id) {
    method everything_is_visible (line 1115) | pub fn everything_is_visible(&self) -> bool {
    method set_everything_is_visible (line 1124) | pub fn set_everything_is_visible(&mut self, value: bool) {
  method default (line 122) | fn default() -> Self {
  type FocusDirection (line 145) | pub enum FocusDirection {
    method is_cardinal (line 170) | fn is_cardinal(&self) -> bool {
  type Options (line 187) | pub struct Options {
    method begin_pass (line 339) | pub fn begin_pass(&mut self, new_raw_input: &RawInput) {
    method theme (line 344) | pub(crate) fn theme(&self) -> Theme {
    method style (line 352) | pub(crate) fn style(&self) -> &std::sync::Arc<Style> {
    method style_mut (line 359) | pub(crate) fn style_mut(&mut self) -> &mut std::sync::Arc<Style> {
    method ui (line 369) | pub fn ui(&mut self, ui: &mut crate::Ui) {
  method default (line 308) | fn default() -> Self {
  type InteractionState (line 465) | pub(crate) struct InteractionState {
    method is_using_pointer (line 530) | pub fn is_using_pointer(&self) -> bool {
  type Focus (line 480) | pub(crate) struct Focus {
    method focused (line 537) | pub fn focused(&self) -> Option<Id> {
    method begin_pass (line 541) | fn begin_pass(&mut self, new_input: &crate::data::input::RawInput) {
    method end_pass (line 593) | pub(crate) fn end_pass(&mut self, used_ids: &IdMap<Rect>) {
    method had_focus_last_frame (line 613) | pub(crate) fn had_focus_last_frame(&self, id: Id) -> bool {
    method interested_in_focus (line 617) | fn interested_in_focus(&mut self, id: Id) {
    method set_modal_layer (line 661) | fn set_modal_layer(&mut self, layer_id: LayerId) {
    method top_modal_layer (line 665) | pub(crate) fn top_modal_layer(&self) -> Option<LayerId> {
    method reset_focus (line 669) | fn reset_focus(&mut self) {
    method find_widget_in_direction (line 673) | fn find_widget_in_direction(&mut self, new_rects: &IdMap<Rect>) -> Opt...
  type FocusWidget (line 514) | struct FocusWidget {
    method new (line 520) | pub fn new(id: Id) -> Self {
  type OpenPopup (line 1000) | struct OpenPopup {
    method new (line 1013) | fn new(id: Id, pos: Option<Pos2>) -> Self {
  type OrderMap (line 1132) | type OrderMap = HashMap<LayerId, usize>;
  type Areas (line 1139) | pub struct Areas {
    method count (line 1168) | pub(crate) fn count(&self) -> usize {
    method get (line 1172) | pub(crate) fn get(&self, id: Id) -> Option<&area::AreaState> {
    method order (line 1177) | pub(crate) fn order(&self) -> &[LayerId] {
    method compare_order (line 1184) | pub(crate) fn compare_order(&self, a: LayerId, b: LayerId) -> std::cmp...
    method set_state (line 1194) | pub(crate) fn set_state(&mut self, layer_id: LayerId, state: area::Are...
    method layer_id_at (line 1203) | pub fn layer_id_at(
    method visible_last_frame (line 1227) | pub fn visible_last_frame(&self, layer_id: &LayerId) -> bool {
    method is_visible (line 1231) | pub fn is_visible(&self, layer_id: &LayerId) -> bool {
    method visible_layer_ids (line 1236) | pub fn visible_layer_ids(&self) -> ahash::HashSet<LayerId> {
    method visible_windows (line 1244) | pub(crate) fn visible_windows(&self) -> impl Iterator<Item = (LayerId,...
    method move_to_top (line 1252) | pub fn move_to_top(&mut self, layer_id: LayerId) {
    method set_sublayer (line 1270) | pub fn set_sublayer(&mut self, parent: LayerId, child: LayerId) {
    method top_layer_id (line 1288) | pub fn top_layer_id(&self, order: Order) -> Option<LayerId> {
    method parent_layer (line 1296) | pub fn parent_layer(&self, layer_id: LayerId) -> Option<LayerId> {
    method child_layers (line 1307) | pub fn child_layers(&self, layer_id: LayerId) -> impl Iterator<Item = ...
    method is_sublayer (line 1311) | pub(crate) fn is_sublayer(&self, layer: &LayerId) -> bool {
    method end_pass (line 1315) | pub(crate) fn end_pass(&mut self) {
  function memory_impl_send_sync (line 1363) | fn memory_impl_send_sync() {
  function order_map_total_ordering (line 1369) | fn order_map_total_ordering() {

FILE: crates/egui/src/memory/theme.rs
  type Theme (line 6) | pub enum Theme {
    method default_visuals (line 16) | pub fn default_visuals(self) -> crate::Visuals {
    method default_style (line 24) | pub fn default_style(self) -> crate::Style {
    method from_dark_mode (line 32) | pub fn from_dark_mode(dark_mode: bool) -> Self {
    method small_toggle_button (line 41) | pub(crate) fn small_toggle_button(self, ui: &mut crate::Ui) -> Option<...
  type ThemePreference (line 67) | pub enum ThemePreference {
    method from (line 80) | fn from(value: Theme) -> Self {
    method radio_buttons (line 90) | pub fn radio_buttons(&mut self, ui: &mut crate::Ui) {

FILE: crates/egui/src/menu.rs
  type BarState (line 33) | pub struct BarState {
    method load (line 38) | pub fn load(ctx: &Context, bar_id: Id) -> Self {
    method store (line 42) | pub fn store(self, ctx: &Context, bar_id: Id) {
    method bar_menu (line 49) | pub fn bar_menu<R>(
    method has_root (line 58) | pub(crate) fn has_root(&self) -> bool {
    type Target (line 64) | type Target = MenuRootManager;
    method deref (line 66) | fn deref(&self) -> &Self::Target {
    method deref_mut (line 72) | fn deref_mut(&mut self) -> &mut Self::Target {
  function set_menu_style (line 77) | fn set_menu_style(style: &mut Style) {
  function bar (line 91) | pub fn bar<R>(ui: &mut Ui, add_contents: impl FnOnce(&mut Ui) -> R) -> I...
  function menu_button (line 108) | pub fn menu_button<R>(
  function menu_custom_button (line 121) | pub fn menu_custom_button<R>(
  function menu_image_button (line 135) | pub fn menu_image_button<R>(
  function submenu_button (line 152) | pub fn submenu_button<R>(
  function menu_popup (line 162) | fn menu_popup<'c, R>(
  function stationary_menu_impl (line 227) | fn stationary_menu_impl<'c, R>(
  function stationary_menu_button_impl (line 255) | fn stationary_menu_button_impl<'c, R>(
  constant CONTEXT_MENU_ID_STR (line 270) | pub(crate) const CONTEXT_MENU_ID_STR: &str = "__egui::context_menu";
  function context_menu (line 273) | pub fn context_menu(
  function context_menu_opened (line 288) | pub fn context_menu_opened(response: &Response) -> bool {
  type MenuRootManager (line 296) | pub struct MenuRootManager {
    method show (line 304) | pub fn show<R>(
    method is_menu_open (line 320) | fn is_menu_open(&self, id: Id) -> bool {
    type Target (line 326) | type Target = Option<MenuRoot>;
    method deref (line 328) | fn deref(&self) -> &Self::Target {
    method deref_mut (line 334) | fn deref_mut(&mut self) -> &mut Self::Target {
  type MenuRoot (line 341) | pub struct MenuRoot {
    method new (line 347) | pub fn new(position: Pos2, id: Id) -> Self {
    method show (line 354) | pub fn show<R>(
    method stationary_interaction (line 383) | fn stationary_interaction(button: &Response, root: &mut MenuRootManage...
    method context_interaction (line 437) | pub fn context_interaction(response: &Response, root: &mut Option<Self...
    method handle_menu_response (line 464) | pub fn handle_menu_response(root: &mut MenuRootManager, menu_response:...
    method context_click_interaction (line 475) | pub fn context_click_interaction(response: &Response, root: &mut MenuR...
    method stationary_click_interaction (line 481) | pub fn stationary_click_interaction(button: &Response, root: &mut Menu...
  type MenuResponse (line 488) | pub enum MenuResponse {
    method is_close (line 495) | pub fn is_close(&self) -> bool {
  type SubMenuButton (line 500) | pub struct SubMenuButton {
    method new (line 508) | fn new(text: impl Into<WidgetText>, icon: impl Into<WidgetText>, index...
    method visuals (line 516) | fn visuals<'a>(
    method icon (line 530) | pub fn icon(mut self, icon: impl Into<WidgetText>) -> Self {
    method show (line 535) | pub(crate) fn show(self, ui: &mut Ui, menu_state: &MenuState, sub_id: ...
  type SubMenu (line 600) | pub struct SubMenu {
    method new (line 606) | fn new(parent_state: Arc<RwLock<MenuState>>, text: impl Into<WidgetTex...
    method show (line 614) | pub fn show<R>(
  type MenuState (line 635) | pub struct MenuState {
    method new (line 651) | pub fn new(position: Pos2) -> Self {
    method close (line 661) | pub fn close(&mut self) {
    method show_submenu (line 665) | fn show_submenu<R>(
    method area_contains (line 684) | pub fn area_contains(&self, pos: Pos2) -> bool {
    method next_entry_index (line 692) | fn next_entry_index(&mut self) -> usize {
    method submenu_button_interaction (line 698) | fn submenu_button_interaction(&mut self, ui: &Ui, sub_id: Id, button: ...
    method moving_towards_current_submenu (line 723) | fn moving_towards_current_submenu(&self, pointer: &PointerState) -> bo...
    method hovering_current_submenu (line 738) | fn hovering_current_submenu(&self, pointer: &PointerState) -> bool {
    method cascade_close_response (line 748) | fn cascade_close_response(&mut self, response: MenuResponse) {
    method is_open (line 754) | fn is_open(&self, id: Id) -> bool {
    method sub_id (line 758) | fn sub_id(&self) -> Option<Id> {
    method current_submenu (line 762) | fn current_submenu(&self) -> Option<&Arc<RwLock<Self>>> {
    method submenu (line 766) | fn submenu(&self, id: Id) -> Option<&Arc<RwLock<Self>>> {
    method open_submenu (line 772) | fn open_submenu(&mut self, id: Id, pos: Pos2) {
    method close_submenu (line 778) | fn close_submenu(&mut self) {

FILE: crates/egui/src/os.rs
  type OperatingSystem (line 4) | pub enum OperatingSystem {
    method from_target_os (line 32) | pub const fn from_target_os() -> Self {
    method from_user_agent (line 56) | pub fn from_user_agent(user_agent: &str) -> Self {
    method is_mac (line 80) | pub fn is_mac(&self) -> bool {
  method default (line 25) | fn default() -> Self {

FILE: crates/egui/src/painter.rs
  type Painter (line 21) | pub struct Painter {
    method new (line 47) | pub fn new(ctx: Context, layer_id: LayerId, clip_rect: Rect) -> Self {
    method with_layer_id (line 62) | pub fn with_layer_id(mut self, layer_id: LayerId) -> Self {
    method with_clip_rect (line 71) | pub fn with_clip_rect(&self, rect: Rect) -> Self {
    method set_layer_id (line 81) | pub fn set_layer_id(&mut self, layer_id: LayerId) {
    method set_fade_to_color (line 87) | pub fn set_fade_to_color(&mut self, fade_to_color: Option<Color32>) {
    method set_opacity (line 97) | pub fn set_opacity(&mut self, opacity: f32) {
    method multiply_opacity (line 106) | pub fn multiply_opacity(&mut self, opacity: f32) {
    method opacity (line 116) | pub fn opacity(&self) -> f32 {
    method is_visible (line 123) | pub fn is_visible(&self) -> bool {
    method set_invisible (line 128) | pub fn set_invisible(&mut self) {
    method ctx (line 134) | pub fn ctx(&self) -> &Context {
    method pixels_per_point (line 140) | pub fn pixels_per_point(&self) -> f32 {
    method fonts (line 148) | pub fn fonts<R>(&self, reader: impl FnOnce(&FontsView<'_>) -> R) -> R {
    method fonts_mut (line 156) | pub fn fonts_mut<R>(&self, reader: impl FnOnce(&mut FontsView<'_>) -> ...
    method layer_id (line 162) | pub fn layer_id(&self) -> LayerId {
    method clip_rect (line 169) | pub fn clip_rect(&self) -> Rect {
    method shrink_clip_rect (line 179) | pub fn shrink_clip_rect(&mut self, new_clip_rect: Rect) {
    method set_clip_rect (line 189) | pub fn set_clip_rect(&mut self, clip_rect: Rect) {
    method round_to_pixel_center (line 195) | pub fn round_to_pixel_center(&self, point: f32) -> f32 {
    method round_pos_to_pixel_center (line 202) | pub fn round_pos_to_pixel_center(&self, pos: Pos2) -> Pos2 {
    method round_to_pixel (line 209) | pub fn round_to_pixel(&self, point: f32) -> f32 {
    method round_vec_to_pixels (line 216) | pub fn round_vec_to_pixels(&self, vec: Vec2) -> Vec2 {
    method round_pos_to_pixels (line 223) | pub fn round_pos_to_pixels(&self, pos: Pos2) -> Pos2 {
    method round_rect_to_pixels (line 230) | pub fn round_rect_to_pixels(&self, rect: Rect) -> Rect {
    method paint_list (line 238) | fn paint_list<R>(&self, writer: impl FnOnce(&mut PaintList) -> R) -> R {
    method transform_shape (line 242) | fn transform_shape(&self, shape: &mut Shape) {
    method add (line 254) | pub fn add(&self, shape: impl Into<Shape>) -> ShapeIdx {
    method extend (line 267) | pub fn extend<I: IntoIterator<Item = Shape>>(&self, shapes: I) {
    method set (line 283) | pub fn set(&self, idx: ShapeIdx, shape: impl Into<Shape>) {
    method for_each_shape (line 293) | pub fn for_each_shape(&self, mut reader: impl FnMut(&ClippedShape)) {
    method debug_rect (line 307) | pub fn debug_rect(&self, rect: Rect, color: Color32, text: impl ToStri...
    method error (line 324) | pub fn error(&self, pos: Pos2, text: impl std::fmt::Display) -> Rect {
    method debug_text (line 333) | pub fn debug_text(
    method line_segment (line 359) | pub fn line_segment(&self, points: [Pos2; 2], stroke: impl Into<Stroke...
    method line (line 368) | pub fn line(&self, points: Vec<Pos2>, stroke: impl Into<PathStroke>) -...
    method hline (line 373) | pub fn hline(&self, x: impl Into<Rangef>, y: f32, stroke: impl Into<St...
    method vline (line 378) | pub fn vline(&self, x: f32, y: impl Into<Rangef>, stroke: impl Into<St...
    method circle (line 382) | pub fn circle(
    method circle_filled (line 397) | pub fn circle_filled(
    method circle_stroke (line 411) | pub fn circle_stroke(&self, center: Pos2, radius: f32, stroke: impl In...
    method rect (line 421) | pub fn rect(
    method rect_filled (line 438) | pub fn rect_filled(
    method rect_stroke (line 447) | pub fn rect_stroke(
    method arrow (line 458) | pub fn arrow(&self, origin: Pos2, vec: Vec2, stroke: impl Into<Stroke>) {
    method image (line 488) | pub fn image(
    method text (line 510) | pub fn text(
    method layout (line 529) | pub fn layout(
    method layout_no_wrap (line 544) | pub fn layout_no_wrap(
    method layout_job (line 558) | pub fn layout_job(&self, layout_job: LayoutJob) -> Arc<Galley> {
    method galley (line 570) | pub fn galley(&self, pos: Pos2, galley: Arc<Galley>, fallback_color: C...
    method galley_with_override_text_color (line 582) | pub fn galley_with_override_text_color(
  function tint_shape_towards (line 596) | fn tint_shape_towards(shape: &mut Shape, target: Color32) {
  function multiply_opacity (line 604) | fn multiply_opacity(shape: &mut Shape, opacity: f32) {

FILE: crates/egui/src/pass_state.rs
  type TooltipPassState (line 10) | pub struct TooltipPassState {
    method clear (line 17) | pub fn clear(&mut self) {
  type PerWidgetTooltipState (line 24) | pub struct PerWidgetTooltipState {
  type PerLayerState (line 33) | pub struct PerLayerState {
  type ScrollTarget (line 47) | pub struct ScrollTarget {
    method new (line 61) | pub fn new(range: Rangef, align: Option<Align>, animation: style::Scro...
  type AccessKitPassState (line 71) | pub struct AccessKitPassState {
  type DebugRect (line 78) | pub struct DebugRect {
    method paint (line 86) | pub fn paint(self, painter: &Painter) {
  type PassState (line 188) | pub struct PassState {
    method begin_pass (line 258) | pub(crate) fn begin_pass(&mut self, content_rect: Rect) {
    method available_rect (line 298) | pub(crate) fn available_rect(&self) -> Rect {
    method allocate_left_panel (line 307) | pub(crate) fn allocate_left_panel(&mut self, panel_rect: Rect) {
    method allocate_right_panel (line 318) | pub(crate) fn allocate_right_panel(&mut self, panel_rect: Rect) {
    method allocate_top_panel (line 329) | pub(crate) fn allocate_top_panel(&mut self, panel_rect: Rect) {
    method allocate_bottom_panel (line 340) | pub(crate) fn allocate_bottom_panel(&mut self, panel_rect: Rect) {
    method allocate_central_panel (line 350) | pub(crate) fn allocate_central_panel(&mut self, panel_rect: Rect) {
  method default (line 237) | fn default() -> Self {

FILE: crates/egui/src/placer.rs
  type Placer (line 7) | pub(crate) struct Placer {
    method new (line 15) | pub(crate) fn new(max_rect: Rect, layout: Layout) -> Self {
    method set_grid (line 25) | pub(crate) fn set_grid(&mut self, grid: grid::GridLayout) {
    method save_grid (line 29) | pub(crate) fn save_grid(&mut self) {
    method grid (line 36) | pub(crate) fn grid(&self) -> Option<&grid::GridLayout> {
    method is_grid (line 41) | pub(crate) fn is_grid(&self) -> bool {
    method layout (line 46) | pub(crate) fn layout(&self) -> &Layout {
    method prefer_right_to_left (line 51) | pub(crate) fn prefer_right_to_left(&self) -> bool {
    method min_rect (line 56) | pub(crate) fn min_rect(&self) -> Rect {
    method max_rect (line 61) | pub(crate) fn max_rect(&self) -> Rect {
    method force_set_min_rect (line 66) | pub(c

[
  {
    "path": ".cargo/config.toml",
    "chars": 49,
    "preview": "[alias]\nxtask = \"run --quiet --package xtask --\"\n"
  },
  {
    "path": ".gitattributes",
    "chars": 361,
    "preview": "* text=auto eol=lf\nCargo.lock linguist-generated=false\n*.png filter=lfs diff=lfs merge=lfs -text\n*.gif filter=lfs diff=l"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 1391,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: bug\nassignees: ''\n\n---\n\n<!--\nFirst look"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 748,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: feature-request\nassignees: ''\n\n---\n\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/other.md",
    "chars": 247,
    "preview": "---\nname: Other\nabout: For issues that are neither bugs or feature requests\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\nIf "
  },
  {
    "path": ".github/pull_request_template.md",
    "chars": 924,
    "preview": "<!--\nPlease read the \"Making a PR\" section of [`CONTRIBUTING.md`](https://github.com/emilk/egui/blob/main/CONTRIBUTING.m"
  },
  {
    "path": ".github/workflows/cargo_machete.yml",
    "chars": 445,
    "preview": "name: Cargo Machete\n\non: [push, pull_request]\n\njobs:\n  cargo-machete:\n    runs-on: ubuntu-latest\n    timeout-minutes: 15"
  },
  {
    "path": ".github/workflows/deploy_web_demo.yml",
    "chars": 1775,
    "preview": "name: Deploy web demo\n\non:\n  # We only run this on merges to main\n  push:\n    branches: [\"main\"]\n  # Allows you to run t"
  },
  {
    "path": ".github/workflows/enforce_branch_name.yml",
    "chars": 1633,
    "preview": "name: PR Branch Name Check\n\non:\n  pull_request_target:\n    types: [opened, reopened, synchronize]\n\npermissions:\n  issues"
  },
  {
    "path": ".github/workflows/labels.yml",
    "chars": 931,
    "preview": "# https://github.com/marketplace/actions/require-labels\n# Check for existence of labels\n# See all our labels at https://"
  },
  {
    "path": ".github/workflows/link_checker.yml",
    "chars": 843,
    "preview": "name: Link checker\n# on: [pull_request]  # Disabled because it is so broken\non: workflow_dispatch\n\njobs:\n  lychee:\n    n"
  },
  {
    "path": ".github/workflows/png_only_on_lfs.yml",
    "chars": 1026,
    "preview": "name: All; .png on git LFS\n\non: [push, pull_request]\n\njobs:\n  check-binary-files:\n    runs-on: ubuntu-latest\n    timeout"
  },
  {
    "path": ".github/workflows/preview_build.yml",
    "chars": 2014,
    "preview": "# This action builds and deploys egui_demo_app on each pull request created\n# Security notes:\n# The preview deployment i"
  },
  {
    "path": ".github/workflows/preview_cleanup.yml",
    "chars": 1106,
    "preview": "name: Preview Cleanup\n\npermissions:\n  contents: write\n\non:\n  pull_request_target:\n    types:\n      - closed\n\njobs:\n  cle"
  },
  {
    "path": ".github/workflows/preview_comment.yml",
    "chars": 682,
    "preview": "name: preview_comment.yml\non:\n  pull_request_target:\n    types: [opened]\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n    "
  },
  {
    "path": ".github/workflows/preview_deploy.yml",
    "chars": 2258,
    "preview": "name: Preview Deploy\n\npermissions:\n  contents: write\n  pull-requests: write\n\non:\n  workflow_run:\n    workflows:\n      - "
  },
  {
    "path": ".github/workflows/rust.yml",
    "chars": 7579,
    "preview": "on: [push, pull_request]\n\nname: Rust\n\nenv:\n  RUSTFLAGS: -D warnings\n  RUSTDOCFLAGS: -D warnings\n  NIGHTLY_VERSION: night"
  },
  {
    "path": ".github/workflows/typos.yml",
    "chars": 428,
    "preview": "name: Typos\non: [pull_request]\n\njobs:\n  typos:\n    # https://github.com/crate-ci/typos\n    # Add exceptions to .typos.to"
  },
  {
    "path": ".github/workflows/update_kittest_snapshots.yml",
    "chars": 1384,
    "preview": "on:\n  workflow_dispatch:\n    inputs:\n      run_id:\n        description: 'The run ID that produced the artifact'\n        "
  },
  {
    "path": ".gitignore",
    "chars": 179,
    "preview": ".DS_Store\n**/target\n**/target_ra\n**/target_wasm\n**/tests/snapshots/**/*.diff.png\n**/tests/snapshots/**/*.new.png\n**/test"
  },
  {
    "path": ".typos.toml",
    "chars": 3555,
    "preview": "# https://github.com/crate-ci/typos\n# install:  cargo install typos-cli\n# run:      typos\n\n[default.extend-words]\nime = "
  },
  {
    "path": "ARCHITECTURE.md",
    "chars": 2598,
    "preview": "# Architecture\nThis document describes how the crates that make up egui are all connected.\n\nAlso see [`CONTRIBUTING.md`]"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 155041,
    "preview": "# egui changelog\nAll notable changes to the `egui` crate will be documented in this file.\n\nThis is just the changelog fo"
  },
  {
    "path": "CODEOWNERS",
    "chars": 59,
    "preview": "/crates/egui_kittest @lucasmerlin\n/crates/egui-wgpu @Wumpf\n"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5515,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participa"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 8453,
    "preview": "# Contribution Guidelines\n\n## Introduction\n\n`egui` has been an on-and-off weekend project of mine since late 2018. I am "
  },
  {
    "path": "Cargo.toml",
    "chars": 12842,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\n  \"crates/ecolor\",\n  \"crates/egui_demo_app\",\n  \"crates/egui_demo_lib\",\n  \"crates/"
  },
  {
    "path": "LICENSE-APACHE",
    "chars": 10850,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "LICENSE-MIT",
    "chars": 1092,
    "preview": "Copyright (c) 2018-2021 Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\n\nPermission is hereby granted, free of charge, to an"
  },
  {
    "path": "README.md",
    "chars": 25233,
    "preview": "# 🖌 egui: an easy-to-use GUI in pure Rust\n\n[<img alt=\"github\" src=\"https://img.shields.io/badge/github-emilk/egui-8da0cb"
  },
  {
    "path": "RELEASES.md",
    "chars": 4361,
    "preview": "# Releases\n## Cadence\nWe don't have a regular cadence, but there is usually a new major release every two months or so.\n"
  },
  {
    "path": "clippy.toml",
    "chars": 2937,
    "preview": "# There is also a scripts/clippy_wasm/clippy.toml which forbids some methods that are not available in wasm.\n\n# --------"
  },
  {
    "path": "crates/ecolor/CHANGELOG.md",
    "chars": 3533,
    "preview": "# Changelog for ecolor\nAll notable changes to the `ecolor` crate will be noted in this file.\n\n\nThis file is updated upon"
  },
  {
    "path": "crates/ecolor/Cargo.toml",
    "chars": 1390,
    "preview": "[package]\nname = \"ecolor\"\nversion.workspace = true\nauthors = [\"Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\", \"Andreas Re"
  },
  {
    "path": "crates/ecolor/README.md",
    "chars": 695,
    "preview": "# ecolor - egui color library\n\n[![Latest version](https://img.shields.io/crates/v/ecolor.svg)](https://crates.io/crates/"
  },
  {
    "path": "crates/ecolor/src/cint_impl.rs",
    "chars": 3936,
    "preview": "use super::{Color32, Hsva, HsvaGamma, Rgba, linear_f32_from_linear_u8, linear_u8_from_linear_f32};\nuse cint::{Alpha, Col"
  },
  {
    "path": "crates/ecolor/src/color32.rs",
    "chars": 17767,
    "preview": "use crate::{Rgba, fast_round, linear_f32_from_linear_u8};\n\n/// This format is used for space-efficient color representat"
  },
  {
    "path": "crates/ecolor/src/hex_color_macro.rs",
    "chars": 2341,
    "preview": "/// Construct a [`crate::Color32`] from a hex RGB or RGBA string literal.\n///\n/// Requires the \"color-hex\" feature.\n///\n"
  },
  {
    "path": "crates/ecolor/src/hex_color_runtime.rs",
    "chars": 8059,
    "preview": "//! Convert colors to and from the hex-color string format at runtime\n//!\n//! Supports the 3, 4, 6, and 8-digit formats,"
  },
  {
    "path": "crates/ecolor/src/hsva.rs",
    "chars": 6431,
    "preview": "use crate::{\n    Color32, Rgba, gamma_u8_from_linear_f32, linear_f32_from_gamma_u8, linear_u8_from_linear_f32,\n};\n\n/// H"
  },
  {
    "path": "crates/ecolor/src/hsva_gamma.rs",
    "chars": 1424,
    "preview": "use crate::{Color32, Hsva, Rgba, gamma_from_linear, linear_from_gamma};\n\n/// Like Hsva but with the `v` value (brightnes"
  },
  {
    "path": "crates/ecolor/src/lib.rs",
    "chars": 5480,
    "preview": "//! Color conversions and types.\n//!\n//! This crate is built for the wants and needs of [`egui`](https://github.com/emil"
  },
  {
    "path": "crates/ecolor/src/rgba.rs",
    "chars": 8787,
    "preview": "use crate::Color32;\n\n/// 0-1 linear space `RGBA` color with premultiplied alpha.\n///\n/// See [`crate::Color32`] for expl"
  },
  {
    "path": "crates/eframe/CHANGELOG.md",
    "chars": 47433,
    "preview": "# Changelog for eframe\nAll notable changes to the `eframe` crate.\n\nNOTE: [`egui-winit`](../egui-winit/CHANGELOG.md), [`e"
  },
  {
    "path": "crates/eframe/Cargo.toml",
    "chars": 8265,
    "preview": "[package]\nname = \"eframe\"\nversion.workspace = true\nauthors = [\"Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\"]\ndescription"
  },
  {
    "path": "crates/eframe/README.md",
    "chars": 4455,
    "preview": "# eframe: the [`egui`](https://github.com/emilk/egui) framework\n\n[![Latest version](https://img.shields.io/crates/v/efra"
  },
  {
    "path": "crates/eframe/src/epi.rs",
    "chars": 36386,
    "preview": "//! Platform-agnostic interface for writing apps using [`egui`] (epi = egui programming interface).\n//!\n//! `epi` provid"
  },
  {
    "path": "crates/eframe/src/icon_data.rs",
    "chars": 1738,
    "preview": "//! Helpers for loading [`egui::IconData`].\n\nuse egui::IconData;\n\n/// Helpers for working with [`IconData`].\npub trait I"
  },
  {
    "path": "crates/eframe/src/lib.rs",
    "chars": 20435,
    "preview": "//! eframe - the [`egui`] framework crate\n//!\n//! If you are planning to write an app for web or native,\n//! and want to"
  },
  {
    "path": "crates/eframe/src/native/app_icon.rs",
    "chars": 11563,
    "preview": "//! Set the native app icon at runtime.\n//!\n//! TODO(emilk): port this to [`winit`].\n\nuse std::sync::Arc;\n\nuse egui::Ico"
  },
  {
    "path": "crates/eframe/src/native/epi_integration.rs",
    "chars": 13759,
    "preview": "//! Common tools used by [`super::glow_integration`] and [`super::wgpu_integration`].\n\nuse web_time::Instant;\n\nuse std::"
  },
  {
    "path": "crates/eframe/src/native/event_loop_context.rs",
    "chars": 1794,
    "preview": "use std::cell::Cell;\nuse winit::event_loop::ActiveEventLoop;\n\nthread_local! {\n    static CURRENT_EVENT_LOOP: Cell<Option"
  },
  {
    "path": "crates/eframe/src/native/file_storage.rs",
    "chars": 8799,
    "preview": "use std::{\n    collections::HashMap,\n    io::Write as _,\n    path::{Path, PathBuf},\n};\n\n/// The folder where `eframe` wi"
  },
  {
    "path": "crates/eframe/src/native/glow_integration.rs",
    "chars": 59621,
    "preview": "//! Note that this file contains code very similar to [`super::wgpu_integration`].\n//! When making changes to one you of"
  },
  {
    "path": "crates/eframe/src/native/mod.rs",
    "chars": 333,
    "preview": "mod app_icon;\nmod epi_integration;\nmod event_loop_context;\npub mod run;\n\n/// File storage which can be used by native ba"
  },
  {
    "path": "crates/eframe/src/native/run.rs",
    "chars": 18676,
    "preview": "use std::time::Instant;\n\nuse winit::{\n    application::ApplicationHandler,\n    event_loop::{ActiveEventLoop, ControlFlow"
  },
  {
    "path": "crates/eframe/src/native/wgpu_integration.rs",
    "chars": 42513,
    "preview": "//! Note that this file contains code very similar to [`super::glow_integration`].\n//! When making changes to one you of"
  },
  {
    "path": "crates/eframe/src/native/winit_integration.rs",
    "chars": 6027,
    "preview": "use std::{sync::Arc, time::Instant};\n\nuse winit::{\n    event_loop::ActiveEventLoop,\n    window::{Window, WindowId},\n};\n\n"
  },
  {
    "path": "crates/eframe/src/stopwatch.rs",
    "chars": 1220,
    "preview": "#![allow(clippy::allow_attributes, dead_code)] // not used on all platforms\n\nuse web_time::Instant;\n\npub struct Stopwatc"
  },
  {
    "path": "crates/eframe/src/web/app_runner.rs",
    "chars": 14916,
    "preview": "use std::sync::Arc;\n\nuse egui::{TexturesDelta, UserData, ViewportCommand};\n\nuse crate::{App, epi, web::web_painter::WebP"
  },
  {
    "path": "crates/eframe/src/web/backend.rs",
    "chars": 6573,
    "preview": "use std::collections::BTreeMap;\n\nuse egui::mutex::Mutex;\n\nuse crate::epi;\n\nuse super::percent_decode;\n\n// --------------"
  },
  {
    "path": "crates/eframe/src/web/events.rs",
    "chars": 45681,
    "preview": "use crate::web::string_from_js_value;\n\nuse super::{\n    AppRunner, Closure, DEBUG_RESIZE, JsCast as _, JsValue, WebRunne"
  },
  {
    "path": "crates/eframe/src/web/input.rs",
    "chars": 6273,
    "preview": "use super::{AppRunner, canvas_content_rect};\n\npub fn pos_from_mouse_event(\n    canvas: &web_sys::HtmlCanvasElement,\n    "
  },
  {
    "path": "crates/eframe/src/web/mod.rs",
    "chars": 12274,
    "preview": "//! [`egui`] bindings for web apps (compiling to WASM).\n\n#![expect(clippy::missing_errors_doc)] // So many `-> Result<_,"
  },
  {
    "path": "crates/eframe/src/web/panic_handler.rs",
    "chars": 2539,
    "preview": "use std::sync::Arc;\n\nuse egui::mutex::Mutex;\nuse wasm_bindgen::prelude::*;\n\n/// Detects panics, logs them using `console"
  },
  {
    "path": "crates/eframe/src/web/screen_reader.rs",
    "chars": 644,
    "preview": "/// Speak the given text out loud.\npub fn speak(text: &str) {\n    if text.is_empty() {\n        return;\n    }\n\n    if let"
  },
  {
    "path": "crates/eframe/src/web/storage.rs",
    "chars": 1307,
    "preview": "fn local_storage() -> Option<web_sys::Storage> {\n    web_sys::window()?.local_storage().ok()?\n}\n\n/// Read data from loca"
  },
  {
    "path": "crates/eframe/src/web/text_agent.rs",
    "chars": 7467,
    "preview": "//! The text agent is a hidden `<input>` element used to capture\n//! IME and mobile keyboard input events.\n\nuse std::cel"
  },
  {
    "path": "crates/eframe/src/web/web_logger.rs",
    "chars": 4516,
    "preview": "/// Implements [`log::Log`] to log messages to `console.log`, `console.warn`, etc.\npub struct WebLogger {\n    filter: lo"
  },
  {
    "path": "crates/eframe/src/web/web_painter.rs",
    "chars": 1291,
    "preview": "use egui::{Event, UserData};\nuse wasm_bindgen::JsValue;\n\n/// Renderer for a browser canvas.\n/// As of writing we're not "
  },
  {
    "path": "crates/eframe/src/web/web_painter_glow.rs",
    "chars": 6270,
    "preview": "use egui::{Event, UserData, ViewportId};\nuse egui_glow::glow;\nuse std::sync::Arc;\nuse wasm_bindgen::JsCast as _;\nuse was"
  },
  {
    "path": "crates/eframe/src/web/web_painter_wgpu.rs",
    "chars": 13241,
    "preview": "use std::sync::Arc;\n\nuse egui::{Event, UserData, ViewportId};\nuse egui_wgpu::{\n    RenderState, SurfaceErrorAction,\n    "
  },
  {
    "path": "crates/eframe/src/web/web_runner.rs",
    "chars": 10767,
    "preview": "use std::{cell::RefCell, rc::Rc};\n\nuse wasm_bindgen::prelude::*;\n\nuse crate::{App, epi};\n\nuse super::{\n    AppRunner, Pa"
  },
  {
    "path": "crates/egui/Cargo.toml",
    "chars": 2926,
    "preview": "[package]\nname = \"egui\"\nversion.workspace = true\nauthors = [\"Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\"]\ndescription ="
  },
  {
    "path": "crates/egui/README.md",
    "chars": 221,
    "preview": "# GUI implementation\nThis is the core library crate egui. It is fully platform independent without any backend. You give"
  },
  {
    "path": "crates/egui/examples/README.md",
    "chars": 495,
    "preview": "There are no stand-alone egui examples, because egui is not stand-alone!\n\nSee the top-level [examples](https://github.co"
  },
  {
    "path": "crates/egui/src/animation_manager.rs",
    "chars": 3308,
    "preview": "use crate::{\n    Id, IdMap, InputState,\n    emath::{NumExt as _, remap_clamp},\n};\n\n#[derive(Clone, Default)]\npub(crate) "
  },
  {
    "path": "crates/egui/src/atomics/atom.rs",
    "chars": 4049,
    "preview": "use crate::{AtomKind, FontSelection, Id, IntoSizedArgs, IntoSizedResult, SizedAtom, Ui};\nuse emath::{Align2, NumExt as _"
  },
  {
    "path": "crates/egui/src/atomics/atom_ext.rs",
    "chars": 4310,
    "preview": "use crate::{Atom, FontSelection, Id, Ui};\nuse emath::Vec2;\n\n/// A trait for conveniently building [`Atom`]s.\n///\n/// The"
  },
  {
    "path": "crates/egui/src/atomics/atom_kind.rs",
    "chars": 6151,
    "preview": "use crate::{FontSelection, Image, ImageSource, SizedAtomKind, Ui, WidgetText};\nuse emath::Vec2;\nuse epaint::text::TextWr"
  },
  {
    "path": "crates/egui/src/atomics/atom_layout.rs",
    "chars": 17078,
    "preview": "use crate::atomics::ATOMS_SMALL_VEC_SIZE;\nuse crate::{\n    AtomKind, Atoms, FontSelection, Frame, Id, Image, IntoAtoms, "
  },
  {
    "path": "crates/egui/src/atomics/atoms.rs",
    "chars": 7594,
    "preview": "use crate::{Atom, AtomKind, Image, WidgetText};\nuse smallvec::SmallVec;\nuse std::borrow::Cow;\nuse std::ops::{Deref, Dere"
  },
  {
    "path": "crates/egui/src/atomics/mod.rs",
    "chars": 258,
    "preview": "mod atom;\nmod atom_ext;\nmod atom_kind;\nmod atom_layout;\nmod atoms;\nmod sized_atom;\nmod sized_atom_kind;\n\npub use atom::*"
  },
  {
    "path": "crates/egui/src/atomics/sized_atom.rs",
    "chars": 751,
    "preview": "use crate::SizedAtomKind;\nuse emath::Vec2;\n\n/// A [`crate::Atom`] which has been sized.\n#[derive(Clone, Debug)]\npub stru"
  },
  {
    "path": "crates/egui/src/atomics/sized_atom_kind.rs",
    "chars": 695,
    "preview": "use crate::Image;\nuse emath::Vec2;\nuse epaint::Galley;\nuse std::sync::Arc;\n\n/// A sized [`crate::AtomKind`].\n#[derive(Cl"
  },
  {
    "path": "crates/egui/src/cache/cache_storage.rs",
    "chars": 2009,
    "preview": "use super::CacheTrait;\n\n/// A typemap of many caches, all implemented with [`CacheTrait`].\n///\n/// You can access egui's"
  },
  {
    "path": "crates/egui/src/cache/cache_trait.rs",
    "chars": 309,
    "preview": "/// A cache, storing some value for some length of time.\n#[expect(clippy::len_without_is_empty)]\npub trait CacheTrait: '"
  },
  {
    "path": "crates/egui/src/cache/frame_cache.rs",
    "chars": 2406,
    "preview": "use super::CacheTrait;\n\n/// Something that does an expensive computation that we want to cache\n/// to save us from recom"
  },
  {
    "path": "crates/egui/src/cache/frame_publisher.rs",
    "chars": 1571,
    "preview": "use std::hash::Hash;\n\nuse super::CacheTrait;\n\n/// Stores a key:value pair for the duration of this frame and the next.\np"
  },
  {
    "path": "crates/egui/src/cache/mod.rs",
    "chars": 788,
    "preview": "//! Caches for preventing the same value from being recomputed every frame.\n//!\n//! Computing the same thing each frame "
  },
  {
    "path": "crates/egui/src/callstack.rs",
    "chars": 6931,
    "preview": "#[derive(Clone)]\nstruct Frame {\n    /// `_main` is usually as the deepest depth.\n    depth: usize,\n    name: String,\n   "
  },
  {
    "path": "crates/egui/src/containers/area.rs",
    "chars": 23904,
    "preview": "//! Area is a [`Ui`] that has no parent, it floats on the background.\n//! It has no frame or own size. It is potentially"
  },
  {
    "path": "crates/egui/src/containers/close_tag.rs",
    "chars": 820,
    "preview": "#[expect(unused_imports)]\nuse crate::{Ui, UiBuilder};\nuse std::sync::atomic::AtomicBool;\n\n/// A tag to mark a container "
  },
  {
    "path": "crates/egui/src/containers/collapsing_header.rs",
    "chars": 23741,
    "preview": "use std::hash::Hash;\n\nuse crate::{\n    Context, Id, InnerResponse, NumExt as _, Rect, Response, Sense, Stroke, TextStyle"
  },
  {
    "path": "crates/egui/src/containers/combo_box.rs",
    "chars": 16046,
    "preview": "use epaint::Shape;\n\nuse crate::{\n    Align2, Context, Id, InnerResponse, NumExt as _, Painter, Popup, PopupCloseBehavior"
  },
  {
    "path": "crates/egui/src/containers/frame.rs",
    "chars": 16945,
    "preview": "//! Frame container\n\nuse crate::{\n    InnerResponse, Response, Sense, Style, Ui, UiBuilder, UiKind, UiStackInfo, epaint,"
  },
  {
    "path": "crates/egui/src/containers/menu.rs",
    "chars": 19930,
    "preview": "//! Popup menus, context menus and menu bars.\n//!\n//! Show menus via\n//! - [`Popup::menu`] and [`Popup::context_menu`]\n/"
  },
  {
    "path": "crates/egui/src/containers/mod.rs",
    "chars": 878,
    "preview": "//! Containers are pieces of the UI which wraps other pieces of UI. Examples: [`Window`], [`ScrollArea`], [`Resize`], [`"
  },
  {
    "path": "crates/egui/src/containers/modal.rs",
    "chars": 5083,
    "preview": "use emath::{Align2, Vec2};\n\nuse crate::{\n    Area, Color32, Context, Frame, Id, InnerResponse, Order, Response, Sense, U"
  },
  {
    "path": "crates/egui/src/containers/old_popup.rs",
    "chars": 6497,
    "preview": "//! Old and deprecated API for popups. Use [`Popup`] instead.\n#![expect(deprecated)]\n\nuse crate::containers::tooltip::To"
  },
  {
    "path": "crates/egui/src/containers/panel.rs",
    "chars": 37113,
    "preview": "//! Panels are [`Ui`] regions taking up e.g. the left side of a [`Ui`] or screen.\n//!\n//! Panels can either be a child o"
  },
  {
    "path": "crates/egui/src/containers/popup.rs",
    "chars": 22053,
    "preview": "#![expect(deprecated)] // This is a new, safe wrapper around the old `Memory::popup` API.\n\nuse std::iter::once;\n\nuse ema"
  },
  {
    "path": "crates/egui/src/containers/resize.rs",
    "chars": 13480,
    "preview": "use crate::{\n    Align2, Color32, Context, CursorIcon, Id, NumExt as _, Rect, Response, Sense, Shape, Ui,\n    UiBuilder,"
  },
  {
    "path": "crates/egui/src/containers/scene.rs",
    "chars": 9825,
    "preview": "use core::f32;\n\nuse emath::{GuiRounding as _, Pos2};\n\nuse crate::{\n    InnerResponse, LayerId, PointerButton, Rangef, Re"
  },
  {
    "path": "crates/egui/src/containers/scroll_area.rs",
    "chars": 56255,
    "preview": "//! See [`ScrollArea`] for docs.\n\n#![expect(clippy::needless_range_loop)]\n\nuse std::ops::{Add, AddAssign, BitOr, BitOrAs"
  },
  {
    "path": "crates/egui/src/containers/sides.rs",
    "chars": 8335,
    "preview": "use emath::{Align, NumExt as _};\n\nuse crate::{Layout, Ui, UiBuilder};\n\n/// Put some widgets on the left and right sides "
  },
  {
    "path": "crates/egui/src/containers/tooltip.rs",
    "chars": 14051,
    "preview": "use crate::pass_state::PerWidgetTooltipState;\nuse crate::{\n    AreaState, Context, Id, InnerResponse, LayerId, Layout, O"
  },
  {
    "path": "crates/egui/src/containers/window.rs",
    "chars": 46488,
    "preview": "// WARNING: the code in here is horrible. It is a behemoth that needs breaking up into simpler parts.\n\nuse std::sync::Ar"
  },
  {
    "path": "crates/egui/src/context.rs",
    "chars": 170032,
    "preview": "#![warn(missing_docs)] // Let's keep `Context` well-documented.\n\nuse std::{borrow::Cow, cell::RefCell, panic::Location, "
  },
  {
    "path": "crates/egui/src/data/input.rs",
    "chars": 45504,
    "preview": "//! The input needed by egui.\n\nuse epaint::{ColorImage, MarginF32};\n\nuse crate::{\n    Key, OrderedViewportIdMap, Theme, "
  },
  {
    "path": "crates/egui/src/data/key.rs",
    "chars": 16265,
    "preview": "/// Keyboard keys.\n///\n/// egui usually uses logical keys, i.e. after applying any user keymap.\\\n// See comment at the e"
  },
  {
    "path": "crates/egui/src/data/mod.rs",
    "chars": 155,
    "preview": "//! All the data sent between egui and the backend\n\npub mod input;\nmod key;\npub mod output;\nmod user_data;\n\npub use key:"
  },
  {
    "path": "crates/egui/src/data/output.rs",
    "chars": 22143,
    "preview": "//! All the data egui returns to the backend at the end of each frame.\n\nuse crate::{OrderedViewportIdMap, RepaintCause, "
  },
  {
    "path": "crates/egui/src/data/user_data.rs",
    "chars": 1988,
    "preview": "use std::{any::Any, sync::Arc};\n\n/// A wrapper around `dyn Any`, used for passing custom user data\n/// to [`crate::Viewp"
  },
  {
    "path": "crates/egui/src/debug_text.rs",
    "chars": 3883,
    "preview": "//! This is an example of how to create a plugin for egui.\n//!\n//! A plugin is a struct that implements the [`Plugin`] t"
  },
  {
    "path": "crates/egui/src/drag_and_drop.rs",
    "chars": 4712,
    "preview": "use std::{any::Any, sync::Arc};\n\nuse crate::{Context, CursorIcon, Plugin, Ui};\n\n/// Plugin for tracking drag-and-drop pa"
  },
  {
    "path": "crates/egui/src/grid.rs",
    "chars": 16787,
    "preview": "use std::sync::Arc;\n\nuse emath::GuiRounding as _;\n\nuse crate::{\n    Align2, Color32, Context, Id, InnerResponse, NumExt "
  },
  {
    "path": "crates/egui/src/gui_zoom.rs",
    "chars": 3851,
    "preview": "//! Helpers for zooming the whole GUI of an app (changing [`Context::pixels_per_point`]).\n//!\nuse crate::{Button, Contex"
  },
  {
    "path": "crates/egui/src/hit_test.rs",
    "chars": 20437,
    "preview": "use ahash::HashMap;\n\nuse emath::TSTransform;\n\nuse crate::{LayerId, Pos2, Sense, WidgetRect, WidgetRects, ahash, emath, i"
  },
  {
    "path": "crates/egui/src/id.rs",
    "chars": 5070,
    "preview": "// TODO(emilk): have separate types `PositionId` and `UniqueId`. ?\n\nuse std::num::NonZeroU64;\n\n/// egui tracks widgets f"
  },
  {
    "path": "crates/egui/src/input_state/mod.rs",
    "chars": 61138,
    "preview": "mod touch_state;\nmod wheel_state;\n\nuse crate::{\n    SafeAreaInsets,\n    emath::{NumExt as _, Pos2, Rect, Vec2, vec2},\n  "
  },
  {
    "path": "crates/egui/src/input_state/touch_state.rs",
    "chars": 13854,
    "preview": "use std::{collections::BTreeMap, fmt::Debug};\n\nuse crate::{\n    Event, RawInput, TouchId, TouchPhase,\n    data::input::T"
  },
  {
    "path": "crates/egui/src/input_state/wheel_state.rs",
    "chars": 8797,
    "preview": "use emath::{Rect, Vec2, vec2};\n\nuse crate::{InputOptions, Modifiers, MouseWheelUnit, TouchPhase};\n\n/// The current state"
  },
  {
    "path": "crates/egui/src/interaction.rs",
    "chars": 9961,
    "preview": "//! How mouse and touch interzcts with widgets.\n\nuse crate::{Id, InputState, Key, WidgetRects, hit_test, id, input_state"
  },
  {
    "path": "crates/egui/src/introspection.rs",
    "chars": 8608,
    "preview": "//! Showing UI:s for egui/epaint types.\nuse crate::{\n    Color32, CursorIcon, FontFamily, FontId, Label, Mesh, NumExt as"
  },
  {
    "path": "crates/egui/src/layers.rs",
    "chars": 8471,
    "preview": "//! Handles paint layers, i.e. how things\n//! are sometimes painted behind or in front of other things.\n\nuse crate::{Id,"
  },
  {
    "path": "crates/egui/src/layout.rs",
    "chars": 31151,
    "preview": "use emath::GuiRounding as _;\n\nuse crate::{\n    Align,\n    emath::{Align2, NumExt as _, Pos2, Rect, Vec2, pos2, vec2},\n};"
  },
  {
    "path": "crates/egui/src/lib.rs",
    "chars": 23462,
    "preview": "//! `egui`:  an easy-to-use GUI in pure Rust!\n//!\n//! Try the live web demo: <https://www.egui.rs/#demo>. Read more abou"
  },
  {
    "path": "crates/egui/src/load/bytes_loader.rs",
    "chars": 1932,
    "preview": "use super::{\n    Bytes, BytesLoadResult, BytesLoader, BytesPoll, Context, Cow, HashMap, LoadError, Mutex,\n    generate_l"
  },
  {
    "path": "crates/egui/src/load/texture_loader.rs",
    "chars": 4963,
    "preview": "use std::sync::atomic::{AtomicU64, Ordering::Relaxed};\n\nuse emath::Vec2;\n\nuse super::{\n    BytesLoader as _, Context, Ha"
  },
  {
    "path": "crates/egui/src/load.rs",
    "chars": 21264,
    "preview": "//! # Image loading\n//!\n//! If you just want to display some images, [`egui_extras`](https://crates.io/crates/egui_extra"
  },
  {
    "path": "crates/egui/src/memory/mod.rs",
    "chars": 50545,
    "preview": "#![warn(missing_docs)] // Let's keep this file well-documented.` to memory.rs\n\nuse std::num::NonZeroUsize;\n\nuse ahash::{"
  },
  {
    "path": "crates/egui/src/memory/theme.rs",
    "chars": 3674,
    "preview": "use crate::Button;\n\n/// Dark or Light theme.\n#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]\n#[cfg_attr(feature = \"se"
  },
  {
    "path": "crates/egui/src/menu.rs",
    "chars": 24680,
    "preview": "#![expect(deprecated)]\n//! Deprecated menu API - Use [`crate::containers::menu`] instead.\n//!\n//! Usage:\n//! ```\n//! fn "
  },
  {
    "path": "crates/egui/src/os.rs",
    "chars": 2242,
    "preview": "/// An `enum` of common operating systems.\n#[expect(clippy::upper_case_acronyms)] // `Ios` looks too ugly\n#[derive(Clone"
  },
  {
    "path": "crates/egui/src/painter.rs",
    "chars": 19773,
    "preview": "use std::sync::Arc;\n\nuse emath::GuiRounding as _;\nuse epaint::{\n    CircleShape, ClippedShape, CornerRadius, PathStroke,"
  },
  {
    "path": "crates/egui/src/pass_state.rs",
    "chars": 11067,
    "preview": "use ahash::HashMap;\n\nuse crate::{Align, Id, IdMap, LayerId, Rangef, Rect, Vec2, WidgetRects, id::IdSet, style};\n\n#[cfg(d"
  },
  {
    "path": "crates/egui/src/placer.rs",
    "chars": 9932,
    "preview": "use crate::{Layout, Painter, Pos2, Rect, Region, Vec2, grid, vec2};\nuse emath::GuiRounding as _;\n\n#[cfg(debug_assertions"
  },
  {
    "path": "crates/egui/src/plugin.rs",
    "chars": 7545,
    "preview": "use crate::{Context, FullOutput, RawInput, Ui};\nuse ahash::HashMap;\nuse epaint::mutex::{Mutex, MutexGuard};\nuse std::syn"
  },
  {
    "path": "crates/egui/src/response.rs",
    "chars": 40892,
    "preview": "use std::{any::Any, sync::Arc};\n\nuse crate::{\n    Context, CursorIcon, Id, LayerId, PointerButton, Popup, PopupKind, Sen"
  },
  {
    "path": "crates/egui/src/sense.rs",
    "chars": 2973,
    "preview": "/// What sort of interaction is a widget sensitive to?\n#[derive(Clone, Copy, Eq, PartialEq)]\n// #[cfg_attr(feature = \"se"
  },
  {
    "path": "crates/egui/src/style.rs",
    "chars": 99082,
    "preview": "//! egui theme (spacing, colors, etc).\n\nuse emath::Align;\nuse epaint::{\n    AlphaFromCoverage, CornerRadius, Shadow, Str"
  },
  {
    "path": "crates/egui/src/text_selection/accesskit_text.rs",
    "chars": 8665,
    "preview": "use emath::TSTransform;\n\nuse crate::{Context, Galley, Id};\n\nuse super::{CCursorRange, text_cursor_state::is_word_char};\n"
  },
  {
    "path": "crates/egui/src/text_selection/cursor_range.rs",
    "chars": 11200,
    "preview": "use epaint::{Galley, text::cursor::CCursor};\n\nuse crate::{Event, Id, Key, Modifiers, os::OperatingSystem};\n\nuse super::t"
  },
  {
    "path": "crates/egui/src/text_selection/label_text_selection.rs",
    "chars": 25847,
    "preview": "use std::sync::Arc;\n\nuse emath::TSTransform;\n\nuse crate::{\n    Context, CursorIcon, Event, Galley, Id, LayerId, Plugin, "
  },
  {
    "path": "crates/egui/src/text_selection/mod.rs",
    "chars": 309,
    "preview": "//! Helpers regarding text selection for labels and text edit.\n\npub mod accesskit_text;\n\nmod cursor_range;\nmod label_tex"
  },
  {
    "path": "crates/egui/src/text_selection/text_cursor_state.rs",
    "chars": 13499,
    "preview": "//! Text cursor changes/interaction, without modifying the text.\n\nuse epaint::text::{Galley, cursor::CCursor};\nuse unico"
  },
  {
    "path": "crates/egui/src/text_selection/visuals.rs",
    "chars": 5962,
    "preview": "use std::sync::Arc;\n\nuse crate::{Galley, Painter, Rect, Ui, Visuals, pos2, vec2};\n\nuse super::CCursorRange;\n\n#[derive(Cl"
  },
  {
    "path": "crates/egui/src/ui.rs",
    "chars": 114825,
    "preview": "#![warn(missing_docs)] // Let's keep `Ui` well-documented.\n#![expect(clippy::use_self)]\n\nuse std::{any::Any, hash::Hash,"
  },
  {
    "path": "crates/egui/src/ui_builder.rs",
    "chars": 6435,
    "preview": "use std::{hash::Hash, sync::Arc};\n\nuse crate::ClosableTag;\n#[expect(unused_imports)] // Used for doclinks\nuse crate::Ui;"
  },
  {
    "path": "crates/egui/src/ui_stack.rs",
    "chars": 7751,
    "preview": "use std::sync::Arc;\nuse std::{any::Any, iter::FusedIterator};\n\nuse crate::{Direction, Frame, Id, Rect};\n\n/// What kind i"
  },
  {
    "path": "crates/egui/src/util/fixed_cache.rs",
    "chars": 1062,
    "preview": "use epaint::util::hash;\n\nconst FIXED_CACHE_SIZE: usize = 1024; // must be small for web/WASM build (for unknown reason)\n"
  },
  {
    "path": "crates/egui/src/util/id_type_map.rs",
    "chars": 32302,
    "preview": "// TODO(emilk): it is possible we can simplify `Element` further by\n// assuming everything is possibly serializable, and"
  },
  {
    "path": "crates/egui/src/util/mod.rs",
    "chars": 331,
    "preview": "//! Miscellaneous tools used by the rest of egui.\n\npub(crate) mod fixed_cache;\npub mod id_type_map;\npub mod undoer;\n\npub"
  },
  {
    "path": "crates/egui/src/util/undoer.rs",
    "chars": 7583,
    "preview": "use std::collections::VecDeque;\n\n#[derive(Clone, Debug, PartialEq)]\n#[cfg_attr(feature = \"serde\", derive(serde::Deserial"
  },
  {
    "path": "crates/egui/src/viewport.rs",
    "chars": 44420,
    "preview": "//! egui supports multiple viewports, corresponding to multiple native windows.\n//!\n//! Not all egui backends support mu"
  },
  {
    "path": "crates/egui/src/widget_rect.rs",
    "chars": 7287,
    "preview": "use ahash::HashMap;\n\nuse crate::{Id, IdMap, LayerId, Rect, Sense, WidgetInfo};\n\n/// Used to store each widget's [Id], [R"
  },
  {
    "path": "crates/egui/src/widget_style.rs",
    "chars": 5665,
    "preview": "use emath::Vec2;\nuse epaint::{Color32, FontId, Shadow, Stroke, text::TextWrapMode};\n\nuse crate::{\n    Frame, Response, S"
  },
  {
    "path": "crates/egui/src/widget_text.rs",
    "chars": 25499,
    "preview": "use emath::GuiRounding as _;\nuse epaint::text::{IntoTag, TextFormat, VariationCoords};\nuse std::fmt::Formatter;\nuse std:"
  },
  {
    "path": "crates/egui/src/widgets/button.rs",
    "chars": 11845,
    "preview": "use epaint::Margin;\n\nuse crate::{\n    Atom, AtomExt as _, AtomKind, AtomLayout, AtomLayoutResponse, Color32, CornerRadiu"
  },
  {
    "path": "crates/egui/src/widgets/checkbox.rs",
    "chars": 5235,
    "preview": "use emath::Rect;\n\nuse crate::{\n    Atom, AtomLayout, Atoms, Id, IntoAtoms, NumExt as _, Response, Sense, Shape, Ui, Vec2"
  },
  {
    "path": "crates/egui/src/widgets/color_picker.rs",
    "chars": 19790,
    "preview": "//! Color picker widgets.\n\nuse crate::util::fixed_cache::FixedCache;\nuse crate::{\n    Context, DragValue, Id, Painter, P"
  },
  {
    "path": "crates/egui/src/widgets/drag_value.rs",
    "chars": 32769,
    "preview": "use crate::{\n    Atom, AtomExt as _, AtomKind, Atoms, Button, CursorIcon, Id, IntoAtoms, Key, MINUS_CHAR_STR,\n    Modifi"
  },
  {
    "path": "crates/egui/src/widgets/hyperlink.rs",
    "chars": 4188,
    "preview": "use crate::{\n    CursorIcon, Label, Response, Sense, Stroke, Ui, Widget, WidgetInfo, WidgetText, WidgetType,\n    epaint,"
  },
  {
    "path": "crates/egui/src/widgets/image.rs",
    "chars": 31605,
    "preview": "use std::{borrow::Cow, slice::Iter, sync::Arc, time::Duration};\n\nuse emath::{Align, Float as _, GuiRounding as _, NumExt"
  },
  {
    "path": "crates/egui/src/widgets/image_button.rs",
    "chars": 5269,
    "preview": "use crate::{\n    Color32, CornerRadius, Image, Rect, Response, Sense, Ui, Vec2, Widget, WidgetInfo, WidgetType,\n    widg"
  },
  {
    "path": "crates/egui/src/widgets/label.rs",
    "chars": 11834,
    "preview": "use std::sync::Arc;\n\nuse crate::{\n    Align, Direction, FontSelection, Galley, Pos2, Response, Sense, Stroke, TextWrapMo"
  },
  {
    "path": "crates/egui/src/widgets/mod.rs",
    "chars": 5272,
    "preview": "//! Widgets are pieces of GUI such as [`Label`], [`Button`], [`Slider`] etc.\n//!\n//! Example widget uses:\n//! * `ui.add("
  },
  {
    "path": "crates/egui/src/widgets/progress_bar.rs",
    "chars": 7537,
    "preview": "use crate::{\n    Color32, CornerRadius, NumExt as _, Pos2, Rect, Response, Rgba, Sense, Shape, Stroke,\n    TextStyle, Te"
  },
  {
    "path": "crates/egui/src/widgets/radio_button.rs",
    "chars": 3503,
    "preview": "use crate::{\n    Atom, AtomLayout, Atoms, Id, IntoAtoms, NumExt as _, Response, Sense, Ui, Vec2, Widget,\n    WidgetInfo,"
  },
  {
    "path": "crates/egui/src/widgets/selected_label.rs",
    "chars": 383,
    "preview": "#![expect(deprecated, clippy::new_ret_no_self)]\n\nuse crate::WidgetText;\n\n#[deprecated = \"Use `Button::selectable()` inst"
  },
  {
    "path": "crates/egui/src/widgets/separator.rs",
    "chars": 4202,
    "preview": "use crate::{Response, Sense, Ui, Vec2, Widget, vec2, widget_style::SeparatorStyle};\n\n/// A visual separator. A horizonta"
  },
  {
    "path": "crates/egui/src/widgets/slider.rs",
    "chars": 45516,
    "preview": "#![expect(clippy::needless_pass_by_value)] // False positives with `impl ToString`\n\nuse std::ops::RangeInclusive;\n\nuse c"
  },
  {
    "path": "crates/egui/src/widgets/spinner.rs",
    "chars": 2584,
    "preview": "use epaint::{Color32, Pos2, Rect, Shape, Stroke, emath::lerp, vec2};\n\nuse crate::{Response, Sense, Ui, Widget, WidgetInf"
  },
  {
    "path": "crates/egui/src/widgets/text_edit/builder.rs",
    "chars": 46066,
    "preview": "use std::sync::Arc;\n\nuse emath::{Rect, TSTransform};\nuse epaint::{\n    StrokeKind,\n    text::{Galley, LayoutJob, cursor:"
  },
  {
    "path": "crates/egui/src/widgets/text_edit/mod.rs",
    "chars": 205,
    "preview": "mod builder;\nmod output;\nmod state;\nmod text_buffer;\n\npub use {\n    crate::text_selection::TextCursorState, builder::Tex"
  },
  {
    "path": "crates/egui/src/widgets/text_edit/output.rs",
    "chars": 740,
    "preview": "use std::sync::Arc;\n\nuse crate::text::CCursorRange;\n\n/// The output from a [`TextEdit`](crate::TextEdit).\npub struct Tex"
  },
  {
    "path": "crates/egui/src/widgets/text_edit/state.rs",
    "chars": 2559,
    "preview": "use std::sync::Arc;\n\nuse crate::mutex::Mutex;\n\nuse crate::{\n    Context, Id, Vec2,\n    text_selection::{CCursorRange, Te"
  },
  {
    "path": "crates/egui/src/widgets/text_edit/text_buffer.rs",
    "chars": 9451,
    "preview": "use std::{borrow::Cow, ops::Range};\n\nuse epaint::{\n    Galley,\n    text::{TAB_SIZE, cursor::CCursor},\n};\n\nuse crate::{\n "
  },
  {
    "path": "crates/egui-wgpu/CHANGELOG.md",
    "chars": 10411,
    "preview": "# Changelog for egui-wgpu\nAll notable changes to the `egui-wgpu` integration will be noted in this file.\n\n\nThis file is "
  },
  {
    "path": "crates/egui-wgpu/Cargo.toml",
    "chars": 2507,
    "preview": "[package]\nname = \"egui-wgpu\"\nversion.workspace = true\ndescription = \"Bindings for using egui natively using the wgpu lib"
  },
  {
    "path": "crates/egui-wgpu/README.md",
    "chars": 522,
    "preview": "# egui-wgpu\n\n[![Latest version](https://img.shields.io/crates/v/egui-wgpu.svg)](https://crates.io/crates/egui-wgpu)\n[![D"
  },
  {
    "path": "crates/egui-wgpu/src/capture.rs",
    "chars": 10032,
    "preview": "use egui::{UserData, ViewportId};\nuse epaint::ColorImage;\nuse std::sync::{Arc, mpsc};\nuse wgpu::{BindGroupLayout, Multis"
  },
  {
    "path": "crates/egui-wgpu/src/egui.wgsl",
    "chars": 6064,
    "preview": "// Vertex shader bindings\n\nstruct VertexOutput {\n    @location(0) tex_coord: vec2<f32>,\n    @location(1) color: vec4<f32"
  },
  {
    "path": "crates/egui-wgpu/src/lib.rs",
    "chars": 16216,
    "preview": "//! This crates provides bindings between [`egui`](https://github.com/emilk/egui) and [wgpu](https://crates.io/crates/wg"
  },
  {
    "path": "crates/egui-wgpu/src/renderer.rs",
    "chars": 45387,
    "preview": "#![expect(clippy::unwrap_used)] // TODO(emilk): avoid unwraps\n\nuse std::{borrow::Cow, num::NonZeroU64, ops::Range};\n\nuse"
  },
  {
    "path": "crates/egui-wgpu/src/setup.rs",
    "chars": 8155,
    "preview": "use std::sync::Arc;\n\n#[derive(Clone)]\npub enum WgpuSetup {\n    /// Construct a wgpu setup using some predefined settings"
  },
  {
    "path": "crates/egui-wgpu/src/texture_copy.wgsl",
    "chars": 1071,
    "preview": "struct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n};\n\nvar<private> positions: array<vec2f, 3> = array<ve"
  },
  {
    "path": "crates/egui-wgpu/src/winit.rs",
    "chars": 26628,
    "preview": "#![expect(clippy::missing_errors_doc)]\n#![expect(clippy::undocumented_unsafe_blocks)]\n#![expect(clippy::unwrap_used)] //"
  },
  {
    "path": "crates/egui-winit/CHANGELOG.md",
    "chars": 11705,
    "preview": "# Changelog for egui-winit\nAll notable changes to the `egui-winit` integration will be noted in this file.\n\nThis file is"
  },
  {
    "path": "crates/egui-winit/Cargo.toml",
    "chars": 3816,
    "preview": "[package]\nname = \"egui-winit\"\nversion.workspace = true\nauthors = [\"Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\"]\ndescrip"
  },
  {
    "path": "crates/egui-winit/README.md",
    "chars": 571,
    "preview": "# egui-winit\n\n[![Latest version](https://img.shields.io/crates/v/egui-winit.svg)](https://crates.io/crates/egui-winit)\n["
  },
  {
    "path": "crates/egui-winit/src/clipboard.rs",
    "chars": 5823,
    "preview": "use raw_window_handle::RawDisplayHandle;\n\n/// Handles interfacing with the OS clipboard.\n///\n/// If the \"clipboard\" feat"
  },
  {
    "path": "crates/egui-winit/src/lib.rs",
    "chars": 81129,
    "preview": "//! [`egui`] bindings for [`winit`](https://github.com/rust-windowing/winit).\n//!\n//! The library translates winit event"
  },
  {
    "path": "crates/egui-winit/src/safe_area.rs",
    "chars": 2369,
    "preview": "#[cfg(target_os = \"ios\")]\npub use ios::get_safe_area_insets;\n\n#[cfg(target_os = \"ios\")]\nmod ios {\n    use egui::{SafeAre"
  },
  {
    "path": "crates/egui-winit/src/window_settings.rs",
    "chars": 7802,
    "preview": "use egui::ViewportBuilder;\n\n/// Can be used to store native window settings (position and size).\n#[derive(Clone, Copy, D"
  },
  {
    "path": "crates/egui_demo_app/Cargo.toml",
    "chars": 2955,
    "preview": "[package]\nname = \"egui_demo_app\"\nversion.workspace = true\nauthors = [\"Emil Ernerfeldt <emil.ernerfeldt@gmail.com>\"]\nlice"
  },
  {
    "path": "crates/egui_demo_app/README.md",
    "chars": 596,
    "preview": "# egui demo app\nThis app demonstrates [`egui`](https://github.com/emilk/egui/) and [`eframe`](https://github.com/emilk/e"
  },
  {
    "path": "crates/egui_demo_app/src/accessibility_inspector.rs",
    "chars": 9091,
    "preview": "use std::mem;\n\nuse accesskit::{Action, ActionRequest};\nuse accesskit_consumer::{FilterResult, Node, NodeId, Tree, TreeCh"
  },
  {
    "path": "crates/egui_demo_app/src/apps/custom3d_glow.rs",
    "chars": 6639,
    "preview": "#![expect(clippy::undocumented_unsafe_blocks)]\n\nuse std::sync::Arc;\n\nuse eframe::egui_glow;\nuse egui::mutex::Mutex;\nuse "
  }
]

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