Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-09 07:25:35 +01:00
Code Issues Projects Releases Packages Wiki Activity

Rename sink to compositor

Browse source
This commit is contained in:
Brian Anderson 2012-08-19 16:43:44 -07:00
parent 2287862e5a
commit 4e54e0abea
7 changed files with 44 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/servo/content.rs
View file

@ -19,7 +19,7 @@ import dom::base::{Node, NodeScope, define_bindings};
import dom::event::{Event, ResizeEvent}; import dom::event::{Event, ResizeEvent};
import dom::style; import dom::style;
import dom::style::Stylesheet; import dom::style::Stylesheet;
import gfx::renderer::Sink; import gfx::renderer::Compositor;
import parser::html_lexer::spawn_html_lexer_task; import parser::html_lexer::spawn_html_lexer_task;
import parser::html_builder::build_dom; import parser::html_builder::build_dom;
import layout::layout_task; import layout::layout_task;
@ -74,8 +74,8 @@ struct Document {
} }
} }
struct Content<S:Sink send copy> { struct Content<C:Compositor send copy> {
let sink: S; let compositor: C;
let layout: Layout; let layout: Layout;
let from_master: comm::Port<ControlMsg>; let from_master: comm::Port<ControlMsg>;
let event_port: comm::Port<Event>; let event_port: comm::Port<Event>;
@ -88,10 +88,10 @@ struct Content<S:Sink send copy> {
let resource_task: ResourceTask; let resource_task: ResourceTask;
new(layout: Layout, sink: S, from_master: Port<ControlMsg>, new(layout: Layout, compositor: C, from_master: Port<ControlMsg>,
resource_task: ResourceTask) { resource_task: ResourceTask) {
self.layout = layout; self.layout = layout;
self.sink = sink; self.compositor = compositor;
self.from_master = from_master; self.from_master = from_master;
self.event_port = port(); self.event_port = port();
@ -101,7 +101,7 @@ struct Content<S:Sink send copy> {
self.document = none; self.document = none;
self.doc_url = none; self.doc_url = none;
self.sink.add_event_listener(self.event_port.chan()); self.compositor.add_event_listener(self.event_port.chan());
self.resource_task = resource_task; self.resource_task = resource_task;
} }
@ -233,9 +233,9 @@ struct Content<S:Sink send copy> {
} }
} }
fn create_content<S: Sink send copy>(layout: Layout, sink: S, resource_task: ResourceTask) -> Chan<ControlMsg> { fn create_content<S: Compositor send copy>(layout: Layout, compositor: S, resource_task: ResourceTask) -> Chan<ControlMsg> {
do spawn_listener::<ControlMsg> |from_master| { do spawn_listener::<ControlMsg> |from_master| {
Content(layout, sink, from_master, resource_task).start(); Content(layout, compositor, from_master, resource_task).start();
} }
} }

14
src/servo/engine.rs
View file

@ -1,4 +1,4 @@
import gfx::renderer::{Renderer, Sink}; import gfx::renderer::{Renderer, Compositor};
import pipes::{spawn_service, select}; import pipes::{spawn_service, select};
import layout::layout_task; import layout::layout_task;
import layout_task::Layout; import layout_task::Layout;
@ -15,8 +15,8 @@ fn macros() {
include!("macros.rs"); include!("macros.rs");
} }
struct Engine<S:Sink send copy> { struct Engine<C:Compositor send copy> {
let sink: S; let compositor: C;
let renderer: Renderer; let renderer: Renderer;
let resource_task: ResourceTask; let resource_task: ResourceTask;
@ -24,14 +24,14 @@ struct Engine<S:Sink send copy> {
let layout: Layout; let layout: Layout;
let content: comm::Chan<content::ControlMsg>; let content: comm::Chan<content::ControlMsg>;
new(+sink: S) { new(+compositor: C) {
self.sink = sink; self.compositor = compositor;
let renderer = Renderer(sink); let renderer = Renderer(compositor);
let resource_task = ResourceTask(); let resource_task = ResourceTask();
let image_cache_task = image_cache_task(resource_task); let image_cache_task = image_cache_task(resource_task);
let layout = Layout(renderer, image_cache_task); let layout = Layout(renderer, image_cache_task);
let content = create_content(layout, sink, resource_task); let content = create_content(layout, compositor, resource_task);
self.renderer = renderer; self.renderer = renderer;
self.resource_task = resource_task; self.resource_task = resource_task;

26
src/servo/gfx/pngsink.rs → src/servo/gfx/png_compositor.rs
View file

@ -1,11 +1,11 @@
#[doc = " #[doc = "
A graphics sink that renders to PNG format buffers A graphics compositor that renders to PNG format buffers
Each time the renderer renders a frame the bufsink will output a Each time the renderer renders a frame the compositor will output a
`~[u8]` containing the frame in PNG format. `~[u8]` containing the frame in PNG format.
"]; "];
export PngSink, Msg, Exit; export PngCompositor, Msg, Exit;
import libc::{c_int, c_uint, c_void, c_uchar}; import libc::{c_int, c_uint, c_void, c_uchar};
import azure_bg = azure::bindgen; import azure_bg = azure::bindgen;
@ -17,7 +17,7 @@ import cairo::{CAIRO_FORMAT_ARGB32, cairo_surface_t, cairo_status_t, CAIRO_STATU
import cairo_bg = cairo::bindgen; import cairo_bg = cairo::bindgen;
import cairo_bg::{cairo_image_surface_create, cairo_surface_destroy, import cairo_bg::{cairo_image_surface_create, cairo_surface_destroy,
cairo_surface_write_to_png_stream}; cairo_surface_write_to_png_stream};
import renderer::{Renderer, Sink, RenderMsg}; import renderer::{Renderer, Compositor, RenderMsg};
import task::spawn_listener; import task::spawn_listener;
import comm::{Chan, Port, chan, port}; import comm::{Chan, Port, chan, port};
import unsafe::reinterpret_cast; import unsafe::reinterpret_cast;
@ -28,7 +28,7 @@ import dvec::dvec;
import layout::display_list::display_list; import layout::display_list::display_list;
import std::cell::Cell; import std::cell::Cell;
type PngSink = Chan<Msg>; type PngCompositor = Chan<Msg>;
enum Msg { enum Msg {
BeginDrawing(pipes::chan<DrawTarget>), BeginDrawing(pipes::chan<DrawTarget>),
@ -36,7 +36,7 @@ enum Msg {
Exit Exit
} }
impl Chan<Msg> : Sink { impl Chan<Msg> : Compositor {
fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) { fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) {
self.send(BeginDrawing(next_dt)) self.send(BeginDrawing(next_dt))
} }
@ -44,11 +44,11 @@ impl Chan<Msg> : Sink {
self.send(Draw(next_dt, draw_me)) self.send(Draw(next_dt, draw_me))
} }
fn add_event_listener(_listener: Chan<Event>) { fn add_event_listener(_listener: Chan<Event>) {
// No events in this sink. // No events in this compositor.
} }
} }
fn PngSink(output: Chan<~[u8]>) -> PngSink { fn PngCompositor(output: Chan<~[u8]>) -> PngCompositor {
do spawn_listener |po: Port<Msg>| { do spawn_listener |po: Port<Msg>| {
let cairo_surface = ImageSurface(CAIRO_FORMAT_ARGB32, 800, 600); let cairo_surface = ImageSurface(CAIRO_FORMAT_ARGB32, 800, 600);
let draw_target = Cell(DrawTarget(cairo_surface)); let draw_target = Cell(DrawTarget(cairo_surface));
@ -56,11 +56,11 @@ fn PngSink(output: Chan<~[u8]>) -> PngSink {
loop { loop {
match po.recv() { match po.recv() {
BeginDrawing(sender) => { BeginDrawing(sender) => {
debug!("pngsink: begin_drawing"); debug!("png_compositor: begin_drawing");
sender.send(draw_target.take()); sender.send(draw_target.take());
} }
Draw(sender, dt) => { Draw(sender, dt) => {
debug!("pngsink: draw"); debug!("png_compositor: draw");
do_draw(sender, dt.clone(), output, cairo_surface); do_draw(sender, dt.clone(), output, cairo_surface);
} }
Exit => break Exit => break
@ -85,8 +85,8 @@ fn do_draw(sender: pipes::chan<DrawTarget>,
#[test] #[test]
fn sanity_check() { fn sanity_check() {
do listen |self_channel| { do listen |self_channel| {
let sink = PngSink(self_channel); let compositor = PngCompositor(self_channel);
let renderer = Renderer(sink); let renderer = Renderer(compositor);
let dlist : display_list = dvec(); let dlist : display_list = dvec();
renderer.send(RenderMsg(dlist)); renderer.send(RenderMsg(dlist));
@ -94,6 +94,6 @@ fn sanity_check() {
renderer.send(renderer::ExitMsg(exit_chan)); renderer.send(renderer::ExitMsg(exit_chan));
exit_response_from_engine.recv(); exit_response_from_engine.recv();
sink.send(Exit) compositor.send(Exit)
} }
} }

10
src/servo/gfx/renderer.rs
View file

@ -31,16 +31,14 @@ enum Msg {
#[doc = " #[doc = "
The interface used to by the renderer to aquire draw targets for The interface used to by the renderer to aquire draw targets for
each rendered frame and submit them to be drawn to the display each rendered frame and submit them to be drawn to the display
FIXME: Change this name to Compositor.
"] "]
trait Sink { trait Compositor {
fn begin_drawing(+next_dt: pipes::chan<DrawTarget>); fn begin_drawing(+next_dt: pipes::chan<DrawTarget>);
fn draw(+next_dt: pipes::chan<DrawTarget>, +draw_me: DrawTarget); fn draw(+next_dt: pipes::chan<DrawTarget>, +draw_me: DrawTarget);
fn add_event_listener(listener: comm::Chan<Event>); fn add_event_listener(listener: comm::Chan<Event>);
} }
fn Renderer<S: Sink send copy>(sink: S) -> comm::Chan<Msg> { fn Renderer<C: Compositor send copy>(compositor: C) -> comm::Chan<Msg> {
do task::spawn_listener |po: comm::Port<Msg>| { do task::spawn_listener |po: comm::Port<Msg>| {
let (draw_target_ch, draw_target_po) = pipes::stream(); let (draw_target_ch, draw_target_po) = pipes::stream();
let mut draw_target_ch = draw_target_ch; let mut draw_target_ch = draw_target_ch;
@ -48,7 +46,7 @@ fn Renderer<S: Sink send copy>(sink: S) -> comm::Chan<Msg> {
debug!("renderer: beginning rendering loop"); debug!("renderer: beginning rendering loop");
sink.begin_drawing(draw_target_ch); compositor.begin_drawing(draw_target_ch);
loop { loop {
match po.recv() { match po.recv() {
@ -70,7 +68,7 @@ fn Renderer<S: Sink send copy>(sink: S) -> comm::Chan<Msg> {
} }
#debug("renderer: returning surface"); #debug("renderer: returning surface");
sink.draw(draw_target_ch, draw_target.take()); compositor.draw(draw_target_ch, draw_target.take());
} }
} }
ExitMsg(response_ch) => { ExitMsg(response_ch) => {

6
src/servo/platform/osmain.rs
View file

@ -10,7 +10,7 @@ import azure::cairo_hl::ImageSurface;
import comm::*; import comm::*;
import dvec::{DVec, dvec}; import dvec::{DVec, dvec};
import azure::cairo::cairo_surface_t; import azure::cairo::cairo_surface_t;
import gfx::renderer::Sink; import gfx::renderer::Compositor;
import dom::event::{Event, ResizeEvent}; import dom::event::{Event, ResizeEvent};
import layers::ImageLayer; import layers::ImageLayer;
import geom::size::Size2D; import geom::size::Size2D;
@ -122,9 +122,9 @@ fn mainloop(po: Port<Msg>) {
#[doc = " #[doc = "
Implementation to allow the osmain channel to be used as a graphics Implementation to allow the osmain channel to be used as a graphics
sink for the renderer compositor for the renderer
"] "]
impl OSMain : Sink { impl OSMain : Compositor {
fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) { fn begin_drawing(+next_dt: pipes::chan<DrawTarget>) {
self.send(BeginDrawing(next_dt)) self.send(BeginDrawing(next_dt))
} }

2
src/servo/servo.rc
View file

@ -33,7 +33,7 @@ mod gfx {
mod geometry; mod geometry;
mod surface; mod surface;
mod renderer; mod renderer;
mod pngsink; mod png_compositor;
} }
mod image { mod image {

16
src/servo/servo.rs
View file

@ -67,26 +67,26 @@ fn run_pipeline_screen(urls: ~[~str]) {
fn run_pipeline_png(-url: ~str, outfile: ~str) { fn run_pipeline_png(-url: ~str, outfile: ~str) {
// Use a PNG encoder as the graphics sink // Use a PNG encoder as the graphics compositor
import gfx::pngsink; import gfx::png_compositor;
import pngsink::PngSink; import png_compositor::PngCompositor;
import result::{ok, err}; import result::{ok, err};
import io::{Writer, buffered_file_writer}; import io::{Writer, buffered_file_writer};
listen(|pngdata_from_sink| { listen(|pngdata_from_compositor| {
let sink = PngSink(pngdata_from_sink); let compositor = PngCompositor(pngdata_from_compositor);
let engine = Engine(sink); let engine = Engine(compositor);
let engine_chan = engine.start(); let engine_chan = engine.start();
let engine_chan = let engine_chan =
EngineProto::client::LoadURL(engine_chan, make_url(url, none)); EngineProto::client::LoadURL(engine_chan, make_url(url, none));
match buffered_file_writer(outfile) { match buffered_file_writer(outfile) {
ok(writer) => writer.write(pngdata_from_sink.recv()), ok(writer) => writer.write(pngdata_from_compositor.recv()),
err(e) => fail e err(e) => fail e
} }
let engine_chan = EngineProto::client::Exit(engine_chan); let engine_chan = EngineProto::client::Exit(engine_chan);
pipes::recv(engine_chan); pipes::recv(engine_chan);
sink.send(pngsink::Exit); compositor.send(png_compositor::Exit);
}) })
} }