--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -66,51 +66,53 @@ impl Into<WrExternalImageId> for Externa
}
}
const GL_FORMAT_BGRA_GL: gl::GLuint = gl::BGRA;
const GL_FORMAT_BGRA_GLES: gl::GLuint = gl::BGRA_EXT;
fn get_gl_format_bgra(gl: &gl::Gl) -> gl::GLuint {
match gl.get_type() {
- gl::GlType::Gl => {
- GL_FORMAT_BGRA_GL
- }
- gl::GlType::Gles => {
- GL_FORMAT_BGRA_GLES
- }
+ gl::GlType::Gl => GL_FORMAT_BGRA_GL,
+ gl::GlType::Gles => GL_FORMAT_BGRA_GLES,
}
}
#[repr(C)]
pub struct WrByteSlice {
buffer: *const u8,
len: usize,
}
impl WrByteSlice {
pub fn new(slice: &[u8]) -> WrByteSlice {
- WrByteSlice { buffer: &slice[0], len: slice.len() }
+ WrByteSlice {
+ buffer: &slice[0],
+ len: slice.len(),
+ }
}
pub fn as_slice(&self) -> &[u8] {
unsafe { slice::from_raw_parts(self.buffer, self.len) }
}
}
#[repr(C)]
pub struct MutByteSlice {
buffer: *mut u8,
len: usize,
}
impl MutByteSlice {
pub fn new(slice: &mut [u8]) -> MutByteSlice {
let len = slice.len();
- MutByteSlice { buffer: &mut slice[0], len: len }
+ MutByteSlice {
+ buffer: &mut slice[0],
+ len: len,
+ }
}
pub fn as_mut_slice(&mut self) -> &mut [u8] {
unsafe { slice::from_raw_parts_mut(self.buffer, self.len) }
}
}
#[repr(u32)]
@@ -207,30 +209,52 @@ impl<U> From<TypedRect<f32, U>> for WrRe
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct WrMatrix {
values: [f32; 16],
}
impl<'a, U, E> Into<TypedMatrix4D<f32, U, E>> for &'a WrMatrix {
fn into(self) -> TypedMatrix4D<f32, U, E> {
- TypedMatrix4D::row_major(
- self.values[0], self.values[1], self.values[2], self.values[3],
- self.values[4], self.values[5], self.values[6], self.values[7],
- self.values[8], self.values[9], self.values[10], self.values[11],
- self.values[12], self.values[13], self.values[14], self.values[15])
+ TypedMatrix4D::row_major(self.values[0],
+ self.values[1],
+ self.values[2],
+ self.values[3],
+ self.values[4],
+ self.values[5],
+ self.values[6],
+ self.values[7],
+ self.values[8],
+ self.values[9],
+ self.values[10],
+ self.values[11],
+ self.values[12],
+ self.values[13],
+ self.values[14],
+ self.values[15])
}
}
impl<U, E> Into<TypedMatrix4D<f32, U, E>> for WrMatrix {
fn into(self) -> TypedMatrix4D<f32, U, E> {
- TypedMatrix4D::row_major(
- self.values[0], self.values[1], self.values[2], self.values[3],
- self.values[4], self.values[5], self.values[6], self.values[7],
- self.values[8], self.values[9], self.values[10], self.values[11],
- self.values[12], self.values[13], self.values[14], self.values[15])
+ TypedMatrix4D::row_major(self.values[0],
+ self.values[1],
+ self.values[2],
+ self.values[3],
+ self.values[4],
+ self.values[5],
+ self.values[6],
+ self.values[7],
+ self.values[8],
+ self.values[9],
+ self.values[10],
+ self.values[11],
+ self.values[12],
+ self.values[13],
+ self.values[14],
+ self.values[15])
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct WrColor {
r: f32,
g: f32,
@@ -309,39 +333,37 @@ impl Into<BorderRadius> for WrBorderRadi
bottom_left: self.bottom_left.into(),
bottom_right: self.bottom_right.into(),
}
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
-pub struct WrBorderWidths
-{
+pub struct WrBorderWidths {
left: f32,
top: f32,
right: f32,
bottom: f32,
}
impl Into<BorderWidths> for WrBorderWidths {
fn into(self) -> BorderWidths {
BorderWidths {
left: self.left,
top: self.top,
right: self.right,
- bottom: self.bottom
+ bottom: self.bottom,
}
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
-pub struct WrNinePatchDescriptor
-{
+pub struct WrNinePatchDescriptor {
width: u32,
height: u32,
slice: WrSideOffsets2Du32,
}
impl Into<NinePatchDescriptor> for WrNinePatchDescriptor {
fn into(self) -> NinePatchDescriptor {
NinePatchDescriptor {
@@ -349,48 +371,46 @@ impl Into<NinePatchDescriptor> for WrNin
height: self.height,
slice: self.slice.into(),
}
}
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
-pub struct WrSideOffsets2D<T>
-{
+pub struct WrSideOffsets2D<T> {
top: T,
right: T,
bottom: T,
left: T,
}
impl<T: Copy> Into<SideOffsets2D<T>> for WrSideOffsets2D<T> {
fn into(self) -> SideOffsets2D<T> {
SideOffsets2D::new(self.top, self.right, self.bottom, self.left)
}
}
#[repr(u32)]
-pub enum WrRepeatMode
-{
+pub enum WrRepeatMode {
Stretch,
Repeat,
Round,
Space,
}
impl Into<RepeatMode> for WrRepeatMode {
fn into(self) -> RepeatMode {
- match self {
- WrRepeatMode::Stretch => RepeatMode::Stretch,
- WrRepeatMode::Repeat => RepeatMode::Repeat,
- WrRepeatMode::Round => RepeatMode::Round,
- WrRepeatMode::Space => RepeatMode::Space,
- }
- }
+ match self {
+ WrRepeatMode::Stretch => RepeatMode::Stretch,
+ WrRepeatMode::Repeat => RepeatMode::Repeat,
+ WrRepeatMode::Round => RepeatMode::Round,
+ WrRepeatMode::Space => RepeatMode::Space,
+ }
+ }
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct WrImageMask {
image: WrImageKey,
rect: WrRect,
repeat: bool,
@@ -525,49 +545,50 @@ type ReleaseExternalImageCallback = fn(*
pub struct WrExternalImageHandler {
external_image_obj: *mut c_void,
lock_func: LockExternalImageCallback,
unlock_func: UnlockExternalImageCallback,
release_func: ReleaseExternalImageCallback,
}
impl ExternalImageHandler for WrExternalImageHandler {
- fn lock(&mut self, id: ExternalImageId) -> ExternalImage {
+ fn lock(&mut self,
+ id: ExternalImageId)
+ -> ExternalImage {
let image = (self.lock_func)(self.external_image_obj, id.into());
match image.image_type {
WrExternalImageType::NativeTexture => {
ExternalImage {
u0: image.u0,
v0: image.v0,
u1: image.u1,
v1: image.v1,
source: ExternalImageSource::NativeTexture(image.handle),
}
- }
+ },
WrExternalImageType::RawData => {
ExternalImage {
u0: image.u0,
v0: image.v0,
u1: image.u1,
v1: image.v1,
- source: ExternalImageSource::RawData(unsafe {
- slice::from_raw_parts(image.buff,
- image.size)
- }),
+ source: ExternalImageSource::RawData(unsafe { slice::from_raw_parts(image.buff, image.size) }),
}
- }
+ },
}
}
- fn unlock(&mut self, id: ExternalImageId) {
+ fn unlock(&mut self,
+ id: ExternalImageId) {
(self.unlock_func)(self.external_image_obj, id.into());
}
- fn release(&mut self, id: ExternalImageId) {
+ fn release(&mut self,
+ id: ExternalImageId) {
(self.release_func)(self.external_image_obj, id.into());
}
}
/// cbindgen:field-names=[mHandle]
/// cbindgen:struct-gen-op-lt=true
/// cbindgen:struct-gen-op-lte=true
#[repr(C)]
@@ -637,17 +658,19 @@ pub struct WrTransformProperty {
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WrOpacityProperty {
pub id: u64,
pub opacity: f32,
}
-fn get_proc_address(glcontext_ptr: *mut c_void, name: &str) -> *const c_void {
+fn get_proc_address(glcontext_ptr: *mut c_void,
+ name: &str)
+ -> *const c_void {
extern "C" {
fn get_proc_address_from_glcontext(glcontext_ptr: *mut c_void,
procname: *const c_char)
-> *const c_void;
}
let symbol_name = CString::new(name).unwrap();
@@ -673,89 +696,97 @@ extern "C" {
struct CppNotifier {
window_id: WrWindowId,
}
unsafe impl Send for CppNotifier {}
extern "C" {
fn wr_notifier_new_frame_ready(window_id: WrWindowId);
- fn wr_notifier_new_scroll_frame_ready(window_id: WrWindowId, composite_needed: bool);
- fn wr_notifier_external_event(window_id: WrWindowId, raw_event: usize);
+ fn wr_notifier_new_scroll_frame_ready(window_id: WrWindowId,
+ composite_needed: bool);
+ fn wr_notifier_external_event(window_id: WrWindowId,
+ raw_event: usize);
}
impl webrender_traits::RenderNotifier for CppNotifier {
fn new_frame_ready(&mut self) {
unsafe {
wr_notifier_new_frame_ready(self.window_id);
}
}
- fn new_scroll_frame_ready(&mut self, composite_needed: bool) {
+ fn new_scroll_frame_ready(&mut self,
+ composite_needed: bool) {
unsafe {
wr_notifier_new_scroll_frame_ready(self.window_id, composite_needed);
}
}
- fn external_event(&mut self, event: ExternalEvent) {
+ fn external_event(&mut self,
+ event: ExternalEvent) {
unsafe {
wr_notifier_external_event(self.window_id, event.unwrap());
}
}
}
#[no_mangle]
pub extern "C" fn wr_renderer_set_external_image_handler(renderer: &mut WrRenderer,
external_image_handler: *mut WrExternalImageHandler) {
if !external_image_handler.is_null() {
- renderer.set_external_image_handler(Box::new(
- unsafe {
- WrExternalImageHandler {
- external_image_obj: (*external_image_handler).external_image_obj,
- lock_func: (*external_image_handler).lock_func,
- unlock_func: (*external_image_handler).unlock_func,
- release_func: (*external_image_handler).release_func,
- }
- }));
+ renderer.set_external_image_handler(Box::new(unsafe {
+ WrExternalImageHandler {
+ external_image_obj:
+ (*external_image_handler).external_image_obj,
+ lock_func: (*external_image_handler).lock_func,
+ unlock_func: (*external_image_handler).unlock_func,
+ release_func: (*external_image_handler).release_func,
+ }
+ }));
}
}
#[no_mangle]
pub extern "C" fn wr_renderer_update(renderer: &mut WrRenderer) {
renderer.update();
}
#[no_mangle]
-pub extern "C" fn wr_renderer_render(renderer: &mut WrRenderer, width: u32, height: u32) {
+pub extern "C" fn wr_renderer_render(renderer: &mut WrRenderer,
+ width: u32,
+ height: u32) {
renderer.render(DeviceUintSize::new(width, height));
}
// Call wr_renderer_render() before calling this function.
#[no_mangle]
pub unsafe extern "C" fn wr_renderer_readback(renderer: &mut WrRenderer,
width: u32,
height: u32,
dst_buffer: *mut u8,
buffer_size: usize) {
assert!(is_in_render_thread());
renderer.gl().flush();
let mut slice = slice::from_raw_parts_mut(dst_buffer, buffer_size);
- renderer.gl().read_pixels_into_buffer(0,
- 0,
- width as gl::GLsizei,
- height as gl::GLsizei,
- get_gl_format_bgra(renderer.gl()),
- gl::UNSIGNED_BYTE,
- slice);
+ renderer.gl()
+ .read_pixels_into_buffer(0,
+ 0,
+ width as gl::GLsizei,
+ height as gl::GLsizei,
+ get_gl_format_bgra(renderer.gl()),
+ gl::UNSIGNED_BYTE,
+ slice);
}
#[no_mangle]
-pub extern "C" fn wr_renderer_set_profiler_enabled(renderer: &mut WrRenderer, enabled: bool) {
+pub extern "C" fn wr_renderer_set_profiler_enabled(renderer: &mut WrRenderer,
+ enabled: bool) {
renderer.set_profiler_enabled(enabled);
}
#[no_mangle]
pub extern "C" fn wr_renderer_current_epoch(renderer: &mut WrRenderer,
pipeline_id: WrPipelineId,
out_epoch: &mut WrEpoch)
-> bool {
@@ -772,22 +803,21 @@ pub unsafe extern "C" fn wr_renderer_del
Box::from_raw(renderer);
}
pub struct WrRenderedEpochs {
data: Vec<(WrPipelineId, WrEpoch)>,
}
#[no_mangle]
-pub unsafe extern "C" fn wr_renderer_flush_rendered_epochs(renderer: &mut WrRenderer)
- -> *mut WrRenderedEpochs {
+pub unsafe extern "C" fn wr_renderer_flush_rendered_epochs(renderer: &mut WrRenderer) -> *mut WrRenderedEpochs {
let map = renderer.flush_rendered_epochs();
let pipeline_epochs = Box::new(WrRenderedEpochs {
- data: map.into_iter().collect()
- });
+ data: map.into_iter().collect(),
+ });
return Box::into_raw(pipeline_epochs);
}
#[no_mangle]
pub unsafe extern "C" fn wr_rendered_epochs_next(pipeline_epochs: &mut WrRenderedEpochs,
out_pipeline: &mut WrPipelineId,
out_epoch: &mut WrEpoch)
-> bool {
@@ -821,19 +851,19 @@ pub extern "C" fn wr_window_new(window_i
let name = format!("wr-record-{}.bin", window_id.0);
Some(Box::new(BinaryRecorder::new(&PathBuf::from(name))))
} else {
None
};
let gl;
if unsafe { is_glcontext_egl(gl_context) } {
- gl = unsafe { gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
+ gl = unsafe { gl::GlesFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
} else {
- gl = unsafe { gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
+ gl = unsafe { gl::GlFns::load_with(|symbol| get_proc_address(gl_context, symbol)) };
}
gl.clear_color(0.3, 0.0, 0.0, 1.0);
let version = gl.get_string(gl::VERSION);
println!("WebRender - OpenGL version new {}", version);
let opts = RendererOptions {
@@ -846,22 +876,26 @@ pub extern "C" fn wr_window_new(window_i
};
let window_size = DeviceUintSize::new(window_width, window_height);
let (renderer, sender) = match WrRenderer::new(gl, opts, window_size) {
Ok((renderer, sender)) => (renderer, sender),
Err(e) => {
println!(" Failed to create a WrRenderer: {:?}", e);
let msg = CString::new(format!("wr_window_new: {:?}", e)).unwrap();
- unsafe { gfx_critical_note(msg.as_ptr()); }
+ unsafe {
+ gfx_critical_note(msg.as_ptr());
+ }
return false;
- }
+ },
};
- renderer.set_render_notifier(Box::new(CppNotifier { window_id: window_id }));
+ renderer.set_render_notifier(Box::new(CppNotifier {
+ window_id: window_id,
+ }));
*out_api = Box::into_raw(Box::new(sender.create_api()));
*out_renderer = Box::into_raw(Box::new(renderer));
return true;
}
#[no_mangle]
@@ -900,65 +934,66 @@ pub extern "C" fn wr_api_add_blob_image(
pub extern "C" fn wr_api_add_external_image_handle(api: &mut WrAPI,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
external_image_id: u64) {
assert!(unsafe { is_in_compositor_thread() });
api.add_image(image_key,
descriptor.into(),
ImageData::External(ExternalImageData {
- id: ExternalImageId(external_image_id),
- image_type: ExternalImageType::Texture2DHandle
- }),
+ id: ExternalImageId(external_image_id),
+ image_type: ExternalImageType::Texture2DHandle,
+ }),
None);
}
#[no_mangle]
pub extern "C" fn wr_api_add_external_image_buffer(api: &mut WrAPI,
image_key: WrImageKey,
descriptor: &WrImageDescriptor,
external_image_id: u64) {
assert!(unsafe { is_in_compositor_thread() });
api.add_image(image_key,
descriptor.into(),
ImageData::External(ExternalImageData {
- id: ExternalImageId(external_image_id),
- image_type: ExternalImageType::ExternalBuffer
- }),
+ id: ExternalImageId(external_image_id),
+ image_type: ExternalImageType::ExternalBuffer,
+ }),
None);
}
#[no_mangle]
pub extern "C" fn wr_api_update_image(api: &mut WrAPI,
key: WrImageKey,
descriptor: &WrImageDescriptor,
bytes: WrByteSlice) {
assert!(unsafe { is_in_compositor_thread() });
let copied_bytes = bytes.as_slice().to_owned();
- api.update_image(key,
- descriptor.into(),
- ImageData::new(copied_bytes),
- None);
+ api.update_image(key, descriptor.into(), ImageData::new(copied_bytes), None);
}
#[no_mangle]
-pub extern "C" fn wr_api_delete_image(api: &mut WrAPI, key: WrImageKey) {
+pub extern "C" fn wr_api_delete_image(api: &mut WrAPI,
+ key: WrImageKey) {
assert!(unsafe { is_in_compositor_thread() });
api.delete_image(key)
}
#[no_mangle]
-pub extern "C" fn wr_api_set_root_pipeline(api: &mut WrAPI, pipeline_id: WrPipelineId) {
+pub extern "C" fn wr_api_set_root_pipeline(api: &mut WrAPI,
+ pipeline_id: WrPipelineId) {
api.set_root_pipeline(pipeline_id);
api.generate_frame(None);
}
#[no_mangle]
-pub extern "C" fn wr_api_set_window_parameters(api: &mut WrAPI, width: i32, height: i32) {
+pub extern "C" fn wr_api_set_window_parameters(api: &mut WrAPI,
+ width: i32,
+ height: i32) {
let size = DeviceUintSize::new(width as u32, height as u32);
api.set_window_parameters(size, DeviceUintRect::new(DeviceUintPoint::new(0, 0), size));
}
#[no_mangle]
pub unsafe extern "C" fn wr_api_set_root_display_list(api: &mut WrAPI,
epoch: WrEpoch,
viewport_width: f32,
@@ -1018,17 +1053,17 @@ pub extern "C" fn wr_api_generate_frame(
#[no_mangle]
pub extern "C" fn wr_api_generate_frame_with_properties(api: &mut WrAPI,
opacity_array: *const WrOpacityProperty,
opacity_count: usize,
transform_array: *const WrTransformProperty,
transform_count: usize) {
let mut properties = DynamicProperties {
transforms: Vec::new(),
- floats: Vec::new()
+ floats: Vec::new(),
};
if transform_count > 0 {
let transform_slice = unsafe { slice::from_raw_parts(transform_array, transform_count) };
for element in transform_slice.iter() {
let prop = PropertyValue {
key: PropertyBindingKey::new(element.id),
@@ -1051,17 +1086,18 @@ pub extern "C" fn wr_api_generate_frame_
}
}
api.generate_frame(Some(properties));
}
/// cbindgen:function-postfix=WR_DESTRUCTOR_SAFE_FUNC
#[no_mangle]
-pub extern "C" fn wr_api_send_external_event(api: &mut WrAPI, evt: usize) {
+pub extern "C" fn wr_api_send_external_event(api: &mut WrAPI,
+ evt: usize) {
assert!(unsafe { !is_in_render_thread() });
api.send_external_event(ExternalEvent::from_raw(evt));
}
#[no_mangle]
pub extern "C" fn wr_api_add_raw_font(api: &mut WrAPI,
key: WrFontKey,
@@ -1072,19 +1108,19 @@ pub extern "C" fn wr_api_add_raw_font(ap
let font_slice = unsafe { slice::from_raw_parts(font_buffer, buffer_size as usize) };
let mut font_vector = Vec::new();
font_vector.extend_from_slice(font_slice);
api.add_raw_font(key, font_vector);
}
#[no_mangle]
-pub extern "C" fn wr_api_delete_font(api: &mut WrAPI, key: WrFontKey)
-{
- assert!( unsafe { is_in_compositor_thread() });
+pub extern "C" fn wr_api_delete_font(api: &mut WrAPI,
+ key: WrFontKey) {
+ assert!(unsafe { is_in_compositor_thread() });
api.delete_font(key);
}
#[no_mangle]
pub unsafe extern "C" fn wr_api_get_namespace(api: &mut WrAPI) -> WrIdNamespace {
api.id_namespace
}
@@ -1137,37 +1173,36 @@ pub extern "C" fn wr_state_delete(state:
assert!(unsafe { is_in_main_thread() });
unsafe {
Box::from_raw(state);
}
}
#[no_mangle]
-pub extern "C" fn wr_dp_begin(state: &mut WrState, width: u32, height: u32) {
+pub extern "C" fn wr_dp_begin(state: &mut WrState,
+ width: u32,
+ height: u32) {
assert!(unsafe { is_in_main_thread() });
- state.frame_builder
- .dl_builder
- .list
- .clear();
+ state.frame_builder.dl_builder.list.clear();
state.z_index = 0;
let bounds = LayoutRect::new(LayoutPoint::new(0.0, 0.0),
LayoutSize::new(width as f32, height as f32));
state.frame_builder
- .dl_builder
- .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
- bounds,
- 0,
- None,
- TransformStyle::Flat,
- None,
- MixBlendMode::Normal,
- Vec::new());
+ .dl_builder
+ .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
+ bounds,
+ 0,
+ None,
+ TransformStyle::Flat,
+ None,
+ MixBlendMode::Normal,
+ Vec::new());
}
#[no_mangle]
pub extern "C" fn wr_dp_end(state: &mut WrState) {
assert!(unsafe { is_in_main_thread() });
state.frame_builder.dl_builder.pop_stacking_context();
}
@@ -1204,36 +1239,35 @@ pub extern "C" fn wr_dp_push_stacking_co
let mut filters: Vec<FilterOp> = Vec::new();
let opacity = unsafe { opacity.as_ref() };
if let Some(opacity) = opacity {
if *opacity < 1.0 {
filters.push(FilterOp::Opacity(PropertyBinding::Value(*opacity)));
}
} else {
- filters.push(FilterOp::Opacity(
- PropertyBinding::Binding(PropertyBindingKey::new(animation_id))));
+ filters.push(FilterOp::Opacity(PropertyBinding::Binding(PropertyBindingKey::new(animation_id))));
}
let transform = unsafe { transform.as_ref() };
let transform_binding = match transform {
Some(transform) => PropertyBinding::Value(transform.into()),
None => PropertyBinding::Binding(PropertyBindingKey::new(animation_id)),
};
state.frame_builder
- .dl_builder
- .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
- bounds,
- state.z_index,
- Some(transform_binding),
- TransformStyle::Flat,
- None,
- mix_blend_mode,
- filters);
+ .dl_builder
+ .push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
+ bounds,
+ state.z_index,
+ Some(transform_binding),
+ TransformStyle::Flat,
+ None,
+ mix_blend_mode,
+ filters);
}
#[no_mangle]
pub extern "C" fn wr_dp_pop_stacking_context(state: &mut WrState) {
assert!(unsafe { is_in_main_thread() });
state.frame_builder.dl_builder.pop_stacking_context();
}
@@ -1267,39 +1301,39 @@ pub extern "C" fn wr_dp_push_iframe(stat
#[no_mangle]
pub extern "C" fn wr_dp_push_rect(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
color: WrColor) {
assert!(unsafe { is_in_main_thread() });
- state.frame_builder.dl_builder.push_rect(rect.into(),
- clip.into(),
- color.into());
+ state.frame_builder.dl_builder.push_rect(rect.into(), clip.into(), color.into());
}
#[no_mangle]
pub extern "C" fn wr_dp_push_image(state: &mut WrState,
bounds: WrRect,
clip: WrClipRegion,
stretch_size: WrSize,
tile_spacing: WrSize,
image_rendering: WrImageRendering,
key: WrImageKey) {
assert!(unsafe { is_in_main_thread() });
let bounds = bounds.into();
- state.frame_builder.dl_builder.push_image(bounds,
- clip.into(),
- stretch_size.into(),
- tile_spacing.into(),
- image_rendering,
- key);
+ state.frame_builder
+ .dl_builder
+ .push_image(bounds,
+ clip.into(),
+ stretch_size.into(),
+ tile_spacing.into(),
+ image_rendering,
+ key);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_text(state: &mut WrState,
bounds: WrRect,
clip: WrClipRegion,
color: WrColor,
font_key: WrFontKey,
@@ -1309,127 +1343,137 @@ pub extern "C" fn wr_dp_push_text(state:
assert!(unsafe { is_in_main_thread() });
let glyph_slice = unsafe { slice::from_raw_parts(glyphs, glyph_count as usize) };
let glyph_vector: Vec<_> = glyph_slice.iter().map(|x| x.into()).collect();
let colorf = ColorF::new(color.r, color.g, color.b, color.a);
let glyph_options = None; // TODO
- state.frame_builder.dl_builder.push_text(bounds.into(),
- clip.into(),
- &glyph_vector,
- font_key,
- colorf,
- Au::from_f32_px(glyph_size),
- Au::from_px(0),
- glyph_options);
+ state.frame_builder
+ .dl_builder
+ .push_text(bounds.into(),
+ clip.into(),
+ &glyph_vector,
+ font_key,
+ colorf,
+ Au::from_f32_px(glyph_size),
+ Au::from_px(0),
+ glyph_options);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_border(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
widths: WrBorderWidths,
top: WrBorderSide,
right: WrBorderSide,
bottom: WrBorderSide,
left: WrBorderSide,
radius: WrBorderRadius) {
assert!(unsafe { is_in_main_thread() });
let border_details = BorderDetails::Normal(NormalBorder {
- left: left.into(),
- right: right.into(),
- top: top.into(),
- bottom: bottom.into(),
- radius: radius.into(),
- });
- state.frame_builder.dl_builder.push_border(
- rect.into(),
- clip.into(),
- widths.into(),
- border_details);
+ left: left.into(),
+ right: right.into(),
+ top: top.into(),
+ bottom: bottom.into(),
+ radius: radius.into(),
+ });
+ state.frame_builder
+ .dl_builder
+ .push_border(rect.into(), clip.into(), widths.into(), border_details);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_border_image(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
widths: WrBorderWidths,
image: WrImageKey,
patch: WrNinePatchDescriptor,
outset: WrSideOffsets2Df32,
repeat_horizontal: WrRepeatMode,
repeat_vertical: WrRepeatMode) {
- assert!( unsafe { is_in_main_thread() });
- let border_details = BorderDetails::Image(ImageBorder {
- image_key: image,
- patch: patch.into(),
- outset: outset.into(),
- repeat_horizontal: repeat_horizontal.into(),
- repeat_vertical: repeat_vertical.into(),
- });
- state.frame_builder.dl_builder.push_border(
- rect.into(),
- clip.into(),
- widths.into(),
- border_details);
+ assert!(unsafe { is_in_main_thread() });
+ let border_details =
+ BorderDetails::Image(ImageBorder {
+ image_key: image,
+ patch: patch.into(),
+ outset: outset.into(),
+ repeat_horizontal: repeat_horizontal.into(),
+ repeat_vertical: repeat_vertical.into(),
+ });
+ state.frame_builder
+ .dl_builder
+ .push_border(rect.into(), clip.into(), widths.into(), border_details);
}
#[no_mangle]
-pub extern "C" fn wr_dp_push_border_gradient(state: &mut WrState, rect: WrRect, clip: WrClipRegion,
+pub extern "C" fn wr_dp_push_border_gradient(state: &mut WrState,
+ rect: WrRect,
+ clip: WrClipRegion,
widths: WrBorderWidths,
- start_point: WrPoint, end_point: WrPoint,
- stops: *const WrGradientStop, stops_count: usize,
+ start_point: WrPoint,
+ end_point: WrPoint,
+ stops: *const WrGradientStop,
+ stops_count: usize,
extend_mode: WrGradientExtendMode,
outset: WrSideOffsets2Df32) {
- assert!( unsafe { is_in_main_thread() });
+ assert!(unsafe { is_in_main_thread() });
let stops_slice = unsafe { slice::from_raw_parts(stops, stops_count) };
let stops_vector = stops_slice.iter().map(|x| x.into()).collect();
let border_details = BorderDetails::Gradient(GradientBorder {
- gradient: state.frame_builder.dl_builder.create_gradient(
- start_point.into(), end_point.into(),
- stops_vector, extend_mode.into()),
- outset: outset.into(),
- });
- state.frame_builder.dl_builder.push_border(
- rect.into(),
- clip.into(),
- widths.into(),
- border_details);
+ gradient:
+ state.frame_builder
+ .dl_builder
+ .create_gradient(start_point.into(),
+ end_point.into(),
+ stops_vector,
+ extend_mode.into()),
+ outset: outset.into(),
+ });
+ state.frame_builder
+ .dl_builder
+ .push_border(rect.into(), clip.into(), widths.into(), border_details);
}
#[no_mangle]
-pub extern "C" fn wr_dp_push_border_radial_gradient(state: &mut WrState, rect: WrRect, clip: WrClipRegion,
+pub extern "C" fn wr_dp_push_border_radial_gradient(state: &mut WrState,
+ rect: WrRect,
+ clip: WrClipRegion,
widths: WrBorderWidths,
center: WrPoint,
radius: WrSize,
- stops: *const WrGradientStop, stops_count: usize,
+ stops: *const WrGradientStop,
+ stops_count: usize,
extend_mode: WrGradientExtendMode,
outset: WrSideOffsets2Df32) {
- assert!( unsafe { is_in_main_thread() });
+ assert!(unsafe { is_in_main_thread() });
let stops_slice = unsafe { slice::from_raw_parts(stops, stops_count) };
let stops_vector = stops_slice.iter().map(|x| x.into()).collect();
- let border_details = BorderDetails::RadialGradient(RadialGradientBorder {
- gradient: state.frame_builder.dl_builder.create_radial_gradient(center.into(),
- radius.into(),
- stops_vector,
- extend_mode.into()),
- outset: outset.into(),
- });
- state.frame_builder.dl_builder.push_border(
- rect.into(),
- clip.into(),
- widths.into(),
- border_details);
+ let border_details =
+ BorderDetails::RadialGradient(RadialGradientBorder {
+ gradient:
+ state.frame_builder
+ .dl_builder
+ .create_radial_gradient(center.into(),
+ radius.into(),
+ stops_vector,
+ extend_mode.into()),
+ outset: outset.into(),
+ });
+ state.frame_builder
+ .dl_builder
+ .push_border(rect.into(), clip.into(), widths.into(), border_details);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_linear_gradient(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
start_point: WrPoint,
end_point: WrPoint,
@@ -1438,28 +1482,28 @@ pub extern "C" fn wr_dp_push_linear_grad
extend_mode: WrGradientExtendMode,
tile_size: WrSize,
tile_spacing: WrSize) {
assert!(unsafe { is_in_main_thread() });
let stops_slice = unsafe { slice::from_raw_parts(stops, stops_count) };
let stops_vector = stops_slice.iter().map(|x| x.into()).collect();
- let gradient = state.frame_builder.dl_builder.create_gradient(start_point.into(),
- end_point.into(),
- stops_vector,
- extend_mode.into());
+ let gradient = state.frame_builder
+ .dl_builder
+ .create_gradient(start_point.into(),
+ end_point.into(),
+ stops_vector,
+ extend_mode.into());
let rect = rect.into();
let tile_size = tile_size.into();
let tile_spacing = tile_spacing.into();
- state.frame_builder.dl_builder.push_gradient(rect,
- clip.into(),
- gradient,
- tile_size,
- tile_spacing);
+ state.frame_builder
+ .dl_builder
+ .push_gradient(rect, clip.into(), gradient, tile_size, tile_spacing);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_radial_gradient(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
center: WrPoint,
radius: WrSize,
@@ -1468,52 +1512,54 @@ pub extern "C" fn wr_dp_push_radial_grad
extend_mode: WrGradientExtendMode,
tile_size: WrSize,
tile_spacing: WrSize) {
assert!(unsafe { is_in_main_thread() });
let stops_slice = unsafe { slice::from_raw_parts(stops, stops_count) };
let stops_vector = stops_slice.iter().map(|x| x.into()).collect();
- let gradient = state.frame_builder.dl_builder.create_radial_gradient(center.into(),
- radius.into(),
- stops_vector,
- extend_mode.into());
+ let gradient = state.frame_builder
+ .dl_builder
+ .create_radial_gradient(center.into(),
+ radius.into(),
+ stops_vector,
+ extend_mode.into());
let rect = rect.into();
let tile_size = tile_size.into();
let tile_spacing = tile_spacing.into();
- state.frame_builder.dl_builder.push_radial_gradient(rect,
- clip.into(),
- gradient,
- tile_size,
- tile_spacing);
+ state.frame_builder
+ .dl_builder
+ .push_radial_gradient(rect, clip.into(), gradient, tile_size, tile_spacing);
}
#[no_mangle]
pub extern "C" fn wr_dp_push_box_shadow(state: &mut WrState,
rect: WrRect,
clip: WrClipRegion,
box_bounds: WrRect,
offset: WrPoint,
color: WrColor,
blur_radius: f32,
spread_radius: f32,
border_radius: f32,
clip_mode: WrBoxShadowClipMode) {
assert!(unsafe { is_in_main_thread() });
- state.frame_builder.dl_builder.push_box_shadow(rect.into(),
- clip.into(),
- box_bounds.into(),
- offset.into(),
- color.into(),
- blur_radius,
- spread_radius,
- border_radius,
- clip_mode);
+ state.frame_builder
+ .dl_builder
+ .push_box_shadow(rect.into(),
+ clip.into(),
+ box_bounds.into(),
+ offset.into(),
+ color.into(),
+ blur_radius,
+ spread_radius,
+ border_radius,
+ clip_mode);
}
#[no_mangle]
pub unsafe extern "C" fn wr_api_finalize_builder(state: &mut WrState,
dl_descriptor: &mut WrBuiltDisplayListDescriptor,
dl_data: &mut WrVecU8,
aux_descriptor: &mut WrAuxiliaryListsDescriptor,
aux_data: &mut WrVecU8) {
@@ -1540,67 +1586,73 @@ pub unsafe extern "C" fn wr_dp_push_buil
let dl = BuiltDisplayList::from_data(dl_vec, dl_descriptor);
let aux = AuxiliaryLists::from_data(aux_vec, aux_descriptor);
state.frame_builder.dl_builder.push_built_display_list(dl, aux);
}
struct Moz2dImageRenderer {
- images: HashMap<WrImageKey, BlobImageResult>
+ images: HashMap<WrImageKey, BlobImageResult>,
}
impl BlobImageRenderer for Moz2dImageRenderer {
fn request_blob_image(&mut self,
key: WrImageKey,
data: Arc<BlobImageData>,
descriptor: &BlobImageDescriptor,
_dirty_rect: Option<DeviceUintRect>) {
let result = self.render_blob_image(data, descriptor);
self.images.insert(key, result);
}
- fn resolve_blob_image(&mut self, key: WrImageKey) -> BlobImageResult {
+ fn resolve_blob_image(&mut self,
+ key: WrImageKey)
+ -> BlobImageResult {
return match self.images.remove(&key) {
- Some(result) => result,
- None => Err(BlobImageError::InvalidKey),
- }
+ Some(result) => result,
+ None => Err(BlobImageError::InvalidKey),
+ };
}
}
impl Moz2dImageRenderer {
fn new() -> Self {
Moz2dImageRenderer {
images: HashMap::new(),
}
}
- fn render_blob_image(&mut self, data: Arc<BlobImageData>, descriptor: &BlobImageDescriptor) -> BlobImageResult {
- let mut output = Vec::with_capacity(
- (descriptor.width * descriptor.height * descriptor.format.bytes_per_pixel().unwrap()) as usize
- );
+ fn render_blob_image(&mut self,
+ data: Arc<BlobImageData>,
+ descriptor: &BlobImageDescriptor)
+ -> BlobImageResult {
+ let mut output = Vec::with_capacity((descriptor.width * descriptor.height *
+ descriptor.format.bytes_per_pixel().unwrap()) as
+ usize);
unsafe {
if wr_moz2d_render_cb(WrByteSlice::new(&data[..]),
descriptor.width,
descriptor.height,
descriptor.format,
MutByteSlice::new(output.as_mut_slice())) {
return Ok(RasterizedBlobImage {
- width: descriptor.width,
- height: descriptor.height,
- data: output,
- });
+ width: descriptor.width,
+ height: descriptor.height,
+ data: output,
+ });
}
}
Err(BlobImageError::Other("unimplemented!".to_string()))
}
}
extern "C" {
// TODO: figure out the API for tiled blob images.
fn wr_moz2d_render_cb(blob: WrByteSlice,
width: u32,
height: u32,
format: WrImageFormat,
- output: MutByteSlice) -> bool;
+ output: MutByteSlice)
+ -> bool;
}