Attachment #8822400 for bug #1298588

Attachment #8822400: part 13. Make sure Device has a ComputedValues for stylo for bug #1298588

View | Details | Raw Unified | Return to bug 1298588
Collapse All | Expand All





        }
    };
}

impl PerDocumentStyleData {
    pub fn new(pres_context: RawGeckoPresContextBorrowed) -> Self {
        // FIXME(bholley): Real window size.
        let window_size: TypedSize2D<f32, ViewportPx> = TypedSize2D::new(800.0, 600.0);
        let default_computed_values = ComputedValues::default_values(pres_context);

        // FIXME(bz): We're going to need to either update the computed values
        // in the Stylist's Device or give the Stylist a new Device when our
        // default_computed_values changes.
        let device = Device::new(MediaType::Screen, window_size, &default_computed_values);

        let (new_anims_sender, new_anims_receiver) = channel();

        PerDocumentStyleData(AtomicRefCell::new(PerDocumentStyleDataImpl {
            stylist: Arc::new(Stylist::new(device)),
            stylesheets: vec![],
            stylesheets_changed: true,
            new_animations_sender: new_anims_sender,

            work_queue: if *NUM_THREADS <= 1 {
                None
            } else {
                let configuration =
                    rayon::Configuration::new().set_num_threads(*NUM_THREADS);
                rayon::ThreadPool::new(configuration).ok()
            },
            num_threads: *NUM_THREADS,
            default_computed_values: default_computed_values,
        }))
    }

    pub fn borrow(&self) -> AtomicRef<PerDocumentStyleDataImpl> {
        self.0.borrow()
    }

    pub fn borrow_mut(&self) -> AtomicRefMut<PerDocumentStyleDataImpl> {





use app_units::Au;
use cssparser::{Delimiter, Parser, Token};
use euclid::size::{Size2D, TypedSize2D};
use serialize_comma_separated_list;
use std::fmt::{self, Write};
use style_traits::{ToCss, ViewportPx};
use values::computed::{self, ToComputedValue};
use values::specified;
use properties::ComputedValues;
#[cfg(feature = "gecko")]
use std::sync::Arc;

#[derive(Debug, PartialEq)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct MediaList {
    pub media_queries: Vec<MediaQuery>
}

impl ToCss for MediaList {

#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub enum Range<T> {
    Min(T),
    Max(T),
    Eq(T),
}

impl Range<specified::Length> {
    fn to_computed_range(&self, viewport_size: Size2D<Au>, default_values: &ComputedValues) -> Range<Au> {
        // http://dev.w3.org/csswg/mediaqueries3/#units
        // em units are relative to the initial font-size.
        let context = computed::Context {
            is_root_element: false,
            viewport_size: viewport_size,
            inherited_style: default_values,
            // This cloning business is kind of dumb.... It's because Context
            // insists on having an actual ComputedValues inside itself.
            style: default_values.clone(),
            font_metrics_provider: None
        };

        match *self {
            Range::Min(ref width) => Range::Min(width.to_computed_value(&context)),
            Range::Max(ref width) => Range::Max(width.to_computed_value(&context)),
            Range::Eq(ref width) => Range::Eq(width.to_computed_value(&context))
        }
    }
}

    Unknown(Atom),
}

#[derive(Debug)]
#[cfg_attr(feature = "servo", derive(HeapSizeOf))]
pub struct Device {
    pub media_type: MediaType,
    pub viewport_size: TypedSize2D<f32, ViewportPx>,
    #[cfg(feature = "gecko")]
    pub default_values: Arc<ComputedValues>,
}

impl Device {
    #[cfg(feature = "servo")]
    pub fn new(media_type: MediaType, viewport_size: TypedSize2D<f32, ViewportPx>) -> Device {
        Device {
            media_type: media_type,
            viewport_size: viewport_size,
        }
    }

    #[cfg(feature = "servo")]
    pub fn default_values(&self) -> &ComputedValues {
        ComputedValues::initial_values()
    }

    #[cfg(feature = "gecko")]
    pub fn new(media_type: MediaType, viewport_size: TypedSize2D<f32, ViewportPx>,
               default_values: &Arc<ComputedValues>) -> Device {
        Device {
            media_type: media_type,
            viewport_size: viewport_size,
            default_values: default_values.clone(),
        }
    }

    #[cfg(feature = "gecko")]
    pub fn default_values(&self) -> &ComputedValues {
        &*self.default_values
    }

    #[inline]
    pub fn au_viewport_size(&self) -> Size2D<Au> {
        Size2D::new(Au::from_f32_px(self.viewport_size.width),
                    Au::from_f32_px(self.viewport_size.height))
    }

}


                MediaQueryType::MediaType(ref media_type) => *media_type == device.media_type,
                MediaQueryType::All => true,
            };

            // Check if all conditions match (AND condition)
            let query_match = media_match && mq.expressions.iter().all(|expression| {
                match *expression {
                    Expression::Width(ref value) =>
                        value.to_computed_range(viewport_size, device.default_values()).evaluate(viewport_size.width),
                }
            });

            // Apply the logical NOT qualifier to the result
            match mq.qualifier {
                Some(Qualifier::Not) => !query_match,
                _ => query_match,
            }





}

impl<'a> Context<'a> {
    pub fn is_root_element(&self) -> bool { self.is_root_element }
    pub fn viewport_size(&self) -> Size2D<Au> { self.viewport_size }
    pub fn inherited_style(&self) -> &ComputedValues { &self.inherited_style }
    pub fn style(&self) -> &ComputedValues { &self.style }
    pub fn mutate_style(&mut self) -> &mut ComputedValues { &mut self.style }

    /// Creates a dummy computed context for use in multiple places, like
    /// evaluating media queries.
    pub fn initial(viewport_size: Size2D<Au>, is_root_element: bool) -> Self {
        let initial_style = ComputedValues::initial_values();
        // FIXME: Enforce a font metrics provider.
        Context {
            is_root_element: is_root_element,
            viewport_size: viewport_size,
            inherited_style: initial_style,
            style: initial_style.clone(),
            font_metrics_provider: None,
        }
    }
}

pub trait ToComputedValue {
    type ComputedValue;

    #[inline]
    fn to_computed_value(&self, _context: &Context) -> Self::ComputedValue;






}

#[no_mangle]
pub extern "C" fn Servo_StyleSet_RecomputeDefaultStyles(
  raw_data: RawServoStyleSetBorrowed,
  pres_context: RawGeckoPresContextBorrowed) {
    let mut data = PerDocumentStyleData::from_ffi(raw_data).borrow_mut();
    data.default_computed_values = ComputedValues::default_values(pres_context);
    // FIXME(bz): We need to update our Stylist's Device's computed values, but how?
}

#[no_mangle]
pub extern "C" fn Servo_StyleSet_Drop(data: RawServoStyleSetOwned) -> () {
    let _ = data.into_box::<PerDocumentStyleData>();
}



Return to bug 1298588