servoshell/desktop/
app.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5//! Application entry point, runs the event loop.
6
7use std::path::Path;
8use std::rc::Rc;
9use std::time::Instant;
10use std::{env, fs};
11
12use servo::protocol_handler::ProtocolRegistry;
13use servo::{
14    EventLoopWaker, Opts, Preferences, ServoBuilder, ServoUrl, UserContentManager, UserScript,
15};
16use url::Url;
17use winit::application::ApplicationHandler;
18use winit::event::WindowEvent;
19use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoopProxy};
20use winit::window::WindowId;
21
22use super::event_loop::AppEvent;
23use crate::desktop::event_loop::ServoShellEventLoop;
24use crate::desktop::headed_window::HeadedWindow;
25use crate::desktop::headless_window::HeadlessWindow;
26use crate::desktop::protocols;
27use crate::desktop::tracing::trace_winit_event;
28use crate::parser::get_default_url;
29use crate::prefs::ServoShellPreferences;
30use crate::running_app_state::RunningAppState;
31#[cfg(feature = "gamepad")]
32use crate::running_app_state::ServoshellGamepadDelegate;
33use crate::window::{PlatformWindow, ServoShellWindowId};
34
35pub(crate) enum AppState {
36    Initializing,
37    Running(Rc<RunningAppState>),
38    ShuttingDown,
39}
40
41pub struct App {
42    opts: Opts,
43    preferences: Preferences,
44    servoshell_preferences: ServoShellPreferences,
45    waker: Box<dyn EventLoopWaker>,
46    event_loop_proxy: Option<EventLoopProxy<AppEvent>>,
47    initial_url: ServoUrl,
48    t_start: Instant,
49    t: Instant,
50    state: AppState,
51}
52
53impl App {
54    pub fn new(
55        opts: Opts,
56        preferences: Preferences,
57        servo_shell_preferences: ServoShellPreferences,
58        event_loop: &ServoShellEventLoop,
59    ) -> Self {
60        let initial_url = get_default_url(
61            servo_shell_preferences.url.as_deref(),
62            env::current_dir().unwrap(),
63            |path| fs::metadata(path).is_ok(),
64            &servo_shell_preferences,
65        );
66
67        let t = Instant::now();
68        App {
69            opts,
70            preferences,
71            servoshell_preferences: servo_shell_preferences,
72            waker: event_loop.create_event_loop_waker(),
73            event_loop_proxy: event_loop.event_loop_proxy(),
74            initial_url,
75            t_start: t,
76            t,
77            state: AppState::Initializing,
78        }
79    }
80
81    /// Initialize Application once event loop start running.
82    pub fn init(&mut self, active_event_loop: Option<&ActiveEventLoop>) {
83        let mut protocol_registry = ProtocolRegistry::default();
84        let _ = protocol_registry.register(
85            "urlinfo",
86            protocols::urlinfo::UrlInfoProtocolHander::default(),
87        );
88        let _ =
89            protocol_registry.register("servo", protocols::servo::ServoProtocolHandler::default());
90        let _ = protocol_registry.register(
91            "resource",
92            protocols::resource::ResourceProtocolHandler::default(),
93        );
94
95        let servo_builder = ServoBuilder::default()
96            .opts(self.opts.clone())
97            .preferences(self.preferences.clone())
98            .protocol_registry(protocol_registry)
99            .event_loop_waker(self.waker.clone());
100
101        let url = self.initial_url.as_url().clone();
102
103        let servo = servo_builder.build();
104        let platform_window = self.create_platform_window(url, active_event_loop);
105
106        #[cfg(feature = "webxr")]
107        servo.register_webxr_registry(super::webxr::XrDiscoveryWebXrRegistry::new_boxed(
108            platform_window.clone(),
109            active_event_loop,
110            &self.preferences,
111        ));
112
113        servo.setup_logging();
114
115        let user_content_manager = Rc::new(UserContentManager::new(&servo));
116        for script in load_userscripts(self.servoshell_preferences.userscripts_directory.as_deref())
117            .expect("Loading userscripts failed")
118        {
119            user_content_manager.add_script(Rc::new(script));
120        }
121
122        for user_stylesheet in &self.servoshell_preferences.user_stylesheets {
123            user_content_manager.add_stylesheet(user_stylesheet.clone());
124        }
125
126        let running_state = Rc::new(RunningAppState::new(
127            servo,
128            self.servoshell_preferences.clone(),
129            self.waker.clone(),
130            user_content_manager,
131            self.preferences.clone(),
132            #[cfg(feature = "gamepad")]
133            self.event_loop_proxy
134                .clone()
135                .map(ServoshellGamepadDelegate::new)
136                .map(Rc::new),
137        ));
138        running_state.open_window(platform_window, self.initial_url.as_url().clone());
139
140        self.state = AppState::Running(running_state);
141    }
142
143    #[servo::servo_tracing::instrument(level = "debug", skip_all)]
144    fn create_platform_window(
145        &self,
146        url: Url,
147        active_event_loop: Option<&ActiveEventLoop>,
148    ) -> Rc<dyn PlatformWindow> {
149        assert_eq!(
150            self.servoshell_preferences.headless,
151            active_event_loop.is_none()
152        );
153
154        let Some(active_event_loop) = active_event_loop else {
155            return HeadlessWindow::new(&self.servoshell_preferences);
156        };
157
158        HeadedWindow::new(
159            &self.servoshell_preferences,
160            active_event_loop,
161            self.event_loop_proxy
162                .clone()
163                .expect("Should always have event loop proxy in headed mode."),
164            url,
165        )
166    }
167
168    pub fn pump_servo_event_loop(&mut self, active_event_loop: Option<&ActiveEventLoop>) -> bool {
169        let AppState::Running(state) = &self.state else {
170            return false;
171        };
172
173        let create_platform_window = |url: Url| self.create_platform_window(url, active_event_loop);
174        if !state.spin_event_loop(Some(&create_platform_window)) {
175            self.state = AppState::ShuttingDown;
176            return false;
177        }
178        true
179    }
180}
181
182impl ApplicationHandler<AppEvent> for App {
183    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
184        self.init(Some(event_loop));
185    }
186
187    fn window_event(
188        &mut self,
189        event_loop: &ActiveEventLoop,
190        window_id: WindowId,
191        window_event: WindowEvent,
192    ) {
193        let now = Instant::now();
194        trace_winit_event!(
195            window_event,
196            "@{:?} (+{:?}) {window_event:?}",
197            now - self.t_start,
198            now - self.t
199        );
200        self.t = now;
201
202        let AppState::Running(state) = &self.state else {
203            return;
204        };
205
206        if let Some(window) = state.window(ServoShellWindowId::from(u64::from(window_id))) &&
207            let Some(headed_window) = window.platform_window().as_headed_window()
208        {
209            headed_window.handle_winit_window_event(state.clone(), window, window_event);
210        }
211
212        if !self.pump_servo_event_loop(event_loop.into()) {
213            event_loop.exit();
214        }
215        // Block until the window gets an event
216        event_loop.set_control_flow(ControlFlow::Wait);
217    }
218
219    fn user_event(&mut self, event_loop: &ActiveEventLoop, app_event: AppEvent) {
220        let AppState::Running(state) = &self.state else {
221            return;
222        };
223
224        match app_event {
225            AppEvent::Waker => (),
226            AppEvent::Accessibility(ref event) => {
227                if let Some(window) =
228                    state.window(ServoShellWindowId::from(u64::from(event.window_id))) &&
229                    let Some(headed_window) = window.platform_window().as_headed_window()
230                {
231                    headed_window.handle_winit_app_event(state.clone(), app_event);
232                }
233            },
234            AppEvent::Gamepad(event, gamepad_name, gamepad_index) => {
235                state.handle_gamepad_events(event, gamepad_name, gamepad_index);
236            },
237        }
238
239        if !self.pump_servo_event_loop(event_loop.into()) {
240            event_loop.exit();
241        }
242
243        // Block until the window gets an event
244        event_loop.set_control_flow(ControlFlow::Wait);
245    }
246}
247
248fn load_userscripts(userscripts_directory: Option<&Path>) -> std::io::Result<Vec<UserScript>> {
249    let mut userscripts = Vec::new();
250    if let Some(userscripts_directory) = &userscripts_directory {
251        let mut files = std::fs::read_dir(userscripts_directory)?
252            .map(|e| e.map(|entry| entry.path()))
253            .collect::<Result<Vec<_>, _>>()?;
254        files.sort_unstable();
255        for file in files {
256            let script = std::fs::read_to_string(&file)?;
257            userscripts.push(UserScript::new(script, Some(file)));
258        }
259    }
260    Ok(userscripts)
261}
servoshell/desktop/app.rs

servoshell/desktop/
app.rs
