Struct App

pub struct App {

    servo: Option<Servo<dyn WindowPortsMethods>>,
    webviews: Option<WebViewManager<dyn WindowPortsMethods>>,
    event_queue: Vec<EmbedderEvent>,
    suspended: Cell<bool>,
    windows: HashMap<WindowId, Rc<dyn WindowPortsMethods>>,
    minibrowser: Option<Minibrowser>,
    user_agent: Option<String>,
    waker: Box<dyn EventLoopWaker>,
    initial_url: ServoUrl,
    t_start: Instant,
    t: Instant,
    do_not_use_native_titlebar: bool,
    device_pixel_ratio_override: Option<f32>,
}

Fields

servo: Option<Servo<dyn WindowPortsMethods>>

webviews: Option<WebViewManager<dyn WindowPortsMethods>>

event_queue: Vec<EmbedderEvent>

suspended: Cell<bool>

windows: HashMap<WindowId, Rc<dyn WindowPortsMethods>>

minibrowser: Option<Minibrowser>

user_agent: Option<String>

waker: Box<dyn EventLoopWaker>

initial_url: ServoUrl

t_start: Instant

t: Instant

do_not_use_native_titlebar: bool

device_pixel_ratio_override: Option<f32>

Implementations

impl App

pub fn new( events_loop: &EventsLoop, user_agent: Option<String>, url: Option<String>, do_not_use_native_titlebar: bool, device_pixel_ratio_override: Option<f32>, ) -> Self

pub fn init(&mut self, event_loop: Option<&ActiveEventLoop>)

Initialize Application once event loop start running.

pub fn is_animating(&self) -> bool

fn get_events(&mut self) -> Vec<EmbedderEvent>

fn handle_events(&mut self) -> PumpResult

Pumps events and messages between the embedder and Servo, where embedder events flow towards Servo and embedder messages flow away from Servo, and also runs the compositor.

As the embedder, we push embedder events through our event queues, from the App queue and Window queues to the WebViewManager queue, and from the WebViewManager queue to Servo. We receive and collect embedder messages from the various Servo components, then take them out of the Servo interface so that the WebViewManager can handle them.

pub fn handle_events_with_winit( &mut self, event_loop: &ActiveEventLoop, window: Rc<dyn WindowPortsMethods>, )

Handle events with winit contexts

pub fn handle_events_with_headless(&mut self) -> bool

Handle all servo events with headless mode. Return true if servo request to shutdown.

Trait Implementations

impl ApplicationHandler<WakerEvent> for App

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 user_event(&mut self, event_loop: &ActiveEventLoop, event: WakerEvent)

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

fn suspended(&mut self, _: &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 device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

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.