diff --git a/src/servo/platform/common/glut_windowing.rs b/src/servo/platform/common/glut_windowing.rs new file mode 100644 index 00000000000..4aa02260d6c --- /dev/null +++ b/src/servo/platform/common/glut_windowing.rs @@ -0,0 +1,92 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//! A windowing implementation using GLUT. +/// +/// GLUT is a very old and bare-bones toolkit. However, it has good cross-platform support, at +/// least on desktops. It is designed for testing Servo without the need of a UI. + +use compositing::{CompositeCallback, ResizeCallback}; + +use geom::size::Size2D; +use glut::glut::{DOUBLE, WindowHeight, WindowWidth}; +use glut::glut; + +/// A structure responsible for setting up and tearing down the entire windowing system. +pub struct Application; + +impl Application { + pub fn new() -> Application { + glut::init(); + glut::init_display_mode(DOUBLE); + Application + } +} + +/// The type of a window. +pub struct Window { + glut_window: glut::Window, + composite_callback: Option, + resize_callback: Option, +} + +impl Window { + /// Creates a new window. + pub fn new(_: &Application) -> @mut Window { + // Create the GLUT window. + let glut_window = glut::create_window(~"Servo"); + glut::reshape_window(glut_window, 800, 600); + + // Create our window object. + let window = @mut Window { + glut_window: glut_window, + composite_callback: None, + resize_callback: None, + }; + + // Register event handlers. + do glut::reshape_func(window.glut_window) |width, height| { + match window.resize_callback { + None => {} + Some(callback) => callback(width as uint, height as uint), + } + }; + do glut::display_func { + // FIXME(pcwalton): This will not work with multiple windows. + match window.composite_callback { + None => {} + Some(callback) => callback(), + } + }; + + window + } + + /// Returns the size of the window. + pub fn size(&mut self) -> Size2D { + Size2D(glut::get(WindowWidth) as f32, glut::get(WindowHeight) as f32) + } + + /// Presents the window to the screen (perhaps by page flipping). + pub fn present(&mut self) { + glut::swap_buffers(); + glut::post_redisplay(); + } + + /// Registers a callback to run when a composite event occurs. + pub fn set_composite_callback(&mut self, new_composite_callback: CompositeCallback) { + self.composite_callback = Some(new_composite_callback) + } + + /// Registers a callback to run when a resize event occurs. + pub fn set_resize_callback(&mut self, new_resize_callback: ResizeCallback) { + self.resize_callback = Some(new_resize_callback) + } + + /// Spins the event loop. + pub fn check_loop(@mut self) { + glut::check_loop() + } +} + diff --git a/src/servo/platform/common/shared_gl_windowing.rs b/src/servo/platform/common/shared_gl_windowing.rs new file mode 100644 index 00000000000..dda49e5c136 --- /dev/null +++ b/src/servo/platform/common/shared_gl_windowing.rs @@ -0,0 +1,59 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//! A windowing implementation using shared OpenGL textures. +/// +/// In this setup, Servo renders to an OpenGL texture and uses IPC to share that texture with +/// another application. It also uses IPC to handle events. +/// +/// This is designed for sandboxing scenarios which the OpenGL graphics driver is either sandboxed +/// along with the Servo process or trusted. If the OpenGL driver itself is untrusted, then this +/// windowing implementation is not appropriate. + +use compositing::{CompositeCallback, ResizeCallback}; + +use geom::size::Size2D; +use sharegl::base::ShareContext; +use sharegl::platform::Context; + +/// A structure responsible for setting up and tearing down the entire windowing system. +pub struct Application; + +impl Application { + pub fn new() -> Application { + Application + } +} + +/// The type of a window. +pub struct Window(Context); + +impl Window { + /// Creates a new window. + pub fn new(_: &Application) -> @mut Window { + let share_context: Context = ShareContext::new(Size2D(800, 600)); + println(fmt!("Sharing ID is %d", share_context.id())); + @mut Window(share_context) + } + + /// Returns the size of the window. + pub fn size(&mut self) -> Size2D { + Size2D(800.0, 600.0) + } + + /// Presents the window to the screen (perhaps by page flipping). + pub fn present(&mut self) { + (*self).flush(); + } + + /// Registers a callback to run when a composite event occurs. + pub fn set_composite_callback(&mut self, _: CompositeCallback) {} + + /// Registers a callback to run when a resize event occurs. + pub fn set_resize_callback(&mut self, _: ResizeCallback) {} + + /// Returns the next event. + pub fn check_loop(@mut self) {} +} + diff --git a/src/servo/platform/mod.rs b/src/servo/platform/mod.rs new file mode 100644 index 00000000000..fdbd3bf42d9 --- /dev/null +++ b/src/servo/platform/mod.rs @@ -0,0 +1,18 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +//! Platform-specific functionality for Servo. + +#[cfg(not(shared_gl_windowing))] +pub use platform::common::glut_windowing::{Application, Window}; +#[cfg(shared_gl_windowing)] +pub use platform::common::shared_gl_windowing::{Application, Window}; + +pub mod common { + #[cfg(not(shared_gl_windowing))] + pub mod glut_windowing; + #[cfg(shared_gl_windowing)] + pub mod shared_gl_windowing; +} + diff --git a/src/servo/servo.rc b/src/servo/servo.rc index b7ba8307b98..6e466cb769f 100755 --- a/src/servo/servo.rc +++ b/src/servo/servo.rc @@ -115,6 +115,9 @@ pub mod html { pub mod hubbub_html_parser; } +#[path="platform/mod.rs"] +pub mod platform; + #[path = "util/mod.rs"] pub mod util;