Struct App

pub struct App<AppData: 'static + PartialEq, O: FnPersist<AppData, HashMap<Arc<SourceID>, Option<Window>>>> {
    pub instance: Instance,
    pub driver: Weak<Driver>,
    /* private fields */
}

Fields

instance: Instance

driver: Weak<Driver>

Implementations

impl<AppData: PartialEq, O: FnPersist<AppData, HashMap<Arc<SourceID>, Option<Window>>>> App<AppData, O>

pub fn new<T: 'static>( app_state: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, driver_init: impl FnOnce(Weak<Driver>) + 'static, ) -> Result<(Self, EventLoop<T>)>

Examples found in repository

examples/paragraph-rs.rs (lines 184-191)

fn main() {
    let (mut app, event_loop): (App<Blocker, BasicApp>, winit::event_loop::EventLoop<()>) =
        App::new(
            Blocker {
                area: AbsRect::new(-1.0, -1.0, -1.0, -1.0),
            },
            vec![],
            BasicApp {},
            |_| (),
        )
        .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

examples/textbox-rs.rs (lines 122-129)

fn main() {
    let (mut app, event_loop): (App<TextState, BasicApp>, winit::event_loop::EventLoop<()>) =
        App::new(
            TextState {
                text: EditBuffer::new("new text", (0, 0)).into(),
            },
            vec![],
            BasicApp {},
            |_| (),
        )
        .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

examples/basic-rs.rs (lines 217-222)

fn main() {
    let onclick = Box::new(
        |_: mouse_area::MouseAreaEvent,
         mut appdata: CounterState|
         -> Result<CounterState, CounterState> {
            {
                appdata.count += 1;
                Ok(appdata)
            }
        }
        .wrap(),
    );

    let (mut app, event_loop): (
        App<CounterState, BasicApp>,
        winit::event_loop::EventLoop<()>,
    ) = App::new(
        CounterState { count: 0 },
        vec![onclick],
        BasicApp {},
        |_| (),
    )
    .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

examples/grid-rs.rs (lines 275-280)

fn main() {
    let onclick = Box::new(
        |_: mouse_area::MouseAreaEvent,
         mut appdata: CounterState|
         -> Result<CounterState, CounterState> {
            {
                appdata.count += 1;
                Ok(appdata)
            }
        }
        .wrap(),
    );

    let (mut app, event_loop): (
        App<CounterState, BasicApp>,
        winit::event_loop::EventLoop<()>,
    ) = App::new(
        CounterState { count: 0 },
        vec![onclick],
        BasicApp {},
        |_| (),
    )
    .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

examples/list-rs.rs (lines 318-323)

fn main() {
    let onclick = Box::new(
        |_: mouse_area::MouseAreaEvent,
         mut appdata: CounterState|
         -> Result<CounterState, CounterState> {
            {
                appdata.count += 1;
                Ok(appdata)
            }
        }
        .wrap(),
    );

    let (mut app, event_loop): (
        App<CounterState, BasicApp>,
        feather_ui::winit::event_loop::EventLoop<()>,
    ) = App::new(
        CounterState { count: 0 },
        vec![onclick],
        BasicApp {},
        |_| (),
    )
    .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

examples/graph-rs.rs (lines 242-252)

fn main() {
    let handle_input = Box::new(
        |e: mouse_area::MouseAreaEvent,
         mut appdata: GraphState|
         -> Result<GraphState, GraphState> {
            match e {
                mouse_area::MouseAreaEvent::OnClick(MouseButton::Left, pos) => {
                    if let Some(selected) = appdata.selected {
                        for i in 0..appdata.nodes.len() {
                            let diff = appdata.nodes[i] - pos + appdata.offset;
                            if diff.dot(diff) < NODE_RADIUS * NODE_RADIUS {
                                if appdata.edges.contains(&(selected, i)) {
                                    appdata.edges.remove(&(i, selected));
                                    appdata.edges.remove(&(selected, i));
                                } else {
                                    appdata.edges.insert((selected, i));
                                    appdata.edges.insert((i, selected));
                                }
                                break;
                            }
                        }

                        appdata.selected = None;
                    } else {
                        // Check to see if we're anywhere near a node (yes this is inefficient but we don't care right now)
                        for i in 0..appdata.nodes.len() {
                            let diff = appdata.nodes[i] - pos + appdata.offset;
                            if diff.dot(diff) < NODE_RADIUS * NODE_RADIUS {
                                appdata.selected = Some(i);
                                return Ok(appdata);
                            }
                        }

                        // TODO: maybe make this require shift click
                        appdata.nodes.push(pos - appdata.offset);
                    }

                    Ok(appdata)
                }
                mouse_area::MouseAreaEvent::OnDblClick(MouseButton::Left, pos) => {
                    // TODO: winit currently doesn't capture double clicks
                    appdata.nodes.push(pos - appdata.offset);
                    Ok(appdata)
                }
                mouse_area::MouseAreaEvent::OnDrag(MouseButton::Left, diff) => {
                    appdata.offset += diff;
                    Ok(appdata)
                }
                _ => Ok(appdata),
            }
        }
        .wrap(),
    );

    let (mut app, event_loop): (
        App<GraphState, BasicApp>,
        feather_ui::winit::event_loop::EventLoop<()>,
    ) = App::new(
        GraphState {
            nodes: vec![],
            edges: HashSet::new(),
            offset: Vec2::new(-5000.0, -5000.0),
            selected: None,
        },
        vec![handle_input],
        BasicApp {},
        |_| (),
    )
    .unwrap();

    event_loop.run_app(&mut app).unwrap();
}

pub fn new_any_thread<T: 'static>( app_state: AppData, inputs: Vec<AppEvent<AppData>>, outline: O, any_thread: bool, driver_init: impl FnOnce(Weak<Driver>) + 'static, ) -> Result<(Self, EventLoop<T>)>

Trait Implementations

impl<AppData: PartialEq, T: 'static, O: FnPersist<AppData, HashMap<Arc<SourceID>, Option<Window>>>> ApplicationHandler<T> for App<AppData, O>

fn resumed(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been resumed.

fn window_event( &mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent, )

Emitted when the OS sends an event to a winit window.

fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

fn user_event(&mut self, event_loop: &ActiveEventLoop, _: T)

Emitted when an event is sent from EventLoopProxy::send_event.

fn suspended(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been suspended.

fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)

Emitted when new events arrive from the OS to be processed.

fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is about to block and wait for new events.

fn exiting(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is being shut down.

fn memory_warning(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has received a memory warning.