mirror of
https://github.com/emilk/egui.git
synced 2026-08-30 21:30:03 -04:00
2f6fe9c572
* Part of https://github.com/emilk/egui/issues/5113 * Part of https://github.com/emilk/egui/issues/3524 ## What This deprecates `eframe::App::update` and replaces it with two new functions: ```rs pub trait App { /// Called just before `ui`, and in the future this will /// also be called for background apps when needed. fn logic(&mut self, ctx: &egui::Context, frame: &mut Frame) { } /// Show your user interface to the user. fn ui(&mut self, ui: &mut egui::Ui, frame: &mut Frame); … } ``` Similarly, `Context::run` is deprecated in favor of `Context::run_ui`. `Plugin`s are now handed a `Ui` instead of just a `Context` in `on_begin/end_frame`. ## TODO …either in this PR or a later one * [x] Deprecate `App::update` * [x] Deprecate `Context::run` * [x] Change plugins to get a `Ui` * [x] Update kittest * [x] Change viewports to get UI:s (`show_viewport_immediate` etc) - https://github.com/emilk/egui/pull/7779 ## Later PRs * [ ] Deprecate `Panel::show` * [ ] Deprecate `CentralPanel::show` * [ ] Deprecate `CentralPanel` ?
84 lines
2.7 KiB
Rust
84 lines
2.7 KiB
Rust
use egui::Frame;
|
|
|
|
type AppKindContextState<'a, State> = Box<dyn FnMut(&egui::Context, &mut State) + 'a>;
|
|
type AppKindUiState<'a, State> = Box<dyn FnMut(&mut egui::Ui, &mut State) + 'a>;
|
|
type AppKindContext<'a> = Box<dyn FnMut(&egui::Context) + 'a>;
|
|
type AppKindUi<'a> = Box<dyn FnMut(&mut egui::Ui) + 'a>;
|
|
|
|
/// In order to access the [`eframe::App`] trait from the generic `State`, we store a function pointer
|
|
/// here that will return the dyn trait from the struct. In the builder we have the correct where
|
|
/// clause to be able to create this.
|
|
/// Later we can use it anywhere to get the [`eframe::App`] from the `State`.
|
|
#[cfg(feature = "eframe")]
|
|
type AppKindEframe<'a, State> = (fn(&mut State) -> &mut dyn eframe::App, eframe::Frame);
|
|
|
|
pub(crate) enum AppKind<'a, State> {
|
|
Context(AppKindContext<'a>),
|
|
Ui(AppKindUi<'a>),
|
|
ContextState(AppKindContextState<'a, State>),
|
|
UiState(AppKindUiState<'a, State>),
|
|
#[cfg(feature = "eframe")]
|
|
Eframe(AppKindEframe<'a, State>),
|
|
}
|
|
|
|
impl<State> AppKind<'_, State> {
|
|
pub fn run(
|
|
&mut self,
|
|
ui: &mut egui::Ui,
|
|
state: &mut State,
|
|
sizing_pass: bool,
|
|
) -> Option<egui::Response> {
|
|
match self {
|
|
AppKind::Context(f) => {
|
|
debug_assert!(!sizing_pass, "Context closures cannot do a sizing pass");
|
|
f(ui);
|
|
None
|
|
}
|
|
AppKind::ContextState(f) => {
|
|
debug_assert!(!sizing_pass, "Context closures cannot do a sizing pass");
|
|
f(ui, state);
|
|
None
|
|
}
|
|
#[cfg(feature = "eframe")]
|
|
AppKind::Eframe((get_app, frame)) => {
|
|
let app = get_app(state);
|
|
|
|
app.logic(ui, frame);
|
|
|
|
#[expect(deprecated)]
|
|
app.update(ui, frame);
|
|
|
|
app.ui(ui, frame);
|
|
|
|
None
|
|
}
|
|
kind_ui => Some(kind_ui.run_ui(ui, state, sizing_pass)),
|
|
}
|
|
}
|
|
|
|
fn run_ui(
|
|
&mut self,
|
|
ui: &mut egui::Ui,
|
|
state: &mut State,
|
|
sizing_pass: bool,
|
|
) -> egui::Response {
|
|
let mut builder = egui::UiBuilder::new();
|
|
if sizing_pass {
|
|
builder.sizing_pass = true;
|
|
}
|
|
ui.scope_builder(builder, |ui| {
|
|
Frame::central_panel(ui.style())
|
|
.outer_margin(8.0)
|
|
.inner_margin(0.0)
|
|
.show(ui, |ui| match self {
|
|
AppKind::Ui(f) => f(ui),
|
|
AppKind::UiState(f) => f(ui, state),
|
|
_ => unreachable!(
|
|
"run_ui should only be called with AppKind::Ui or AppKind UiState"
|
|
),
|
|
});
|
|
})
|
|
.response
|
|
}
|
|
}
|