Auto merge of #19798 - gootorov:move_cursor_from_mako, r=emilio

style: Move cursor property out of mako  Sub-PR of #19015 r? emilio ---  - [x] `./mach build -d` does not report any errors - [x] `./mach build-geckolib` does not report any errors - [x] `./mach test-tidy` does not report any errors - [x] These changes fix #19775 (github issue number if applicable).  - [x] These changes do not require tests    --- This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/19798)
2025-06-06 16:45:39 +00:00 · 2018-01-20 12:10:58 -06:00 · 2018-01-20 12:10:58 -06:00 · 59033e6970
commit 59033e6970
parent a4808a3649 4ee9eb8563
17 changed files with 413 additions and 360 deletions
--- a/components/compositing/compositor.rs
+++ b/components/compositing/compositor.rs
@ -29,7 +29,7 @@ use std::rc::Rc;
 use std::sync::mpsc::Sender;
 use std::time::{Duration, Instant};
 use style_traits::{CSSPixel, DevicePixel, PinchZoomFactor};
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use style_traits::viewport::ViewportConstraints;
 use time::{precise_time_ns, precise_time_s};
 use touch::{TouchHandler, TouchAction};
@ -771,7 +771,7 @@ impl<Window: WindowMethods> IOCompositor<Window> {
                warn!("Sending event to constellation failed ({}).", e);
            }

-            if let Some(cursor) =  Cursor::from_u8(item.tag.1 as _).ok() {
+            if let Some(cursor) =  CursorKind::from_u8(item.tag.1 as _).ok() {
                let msg = ConstellationMsg::SetCursor(cursor);
                if let Err(e) = self.constellation_chan.send(msg) {
                    warn!("Sending event to constellation failed ({}).", e);
--- a/components/compositing/compositor_thread.rs
+++ b/components/compositing/compositor_thread.rs
@ -17,7 +17,7 @@ use script_traits::{AnimationState, ConstellationMsg, EventResult, LoadData};
 use servo_url::ServoUrl;
 use std::fmt::{Debug, Error, Formatter};
 use std::sync::mpsc::{Receiver, Sender};
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use style_traits::viewport::ViewportConstraints;
 use webrender;
 use webrender_api;
@ -133,7 +133,7 @@ pub enum EmbedderMsg {
    /// Sends an unconsumed key event back to the embedder.
    KeyEvent(Option<TopLevelBrowsingContextId>, Option<char>, Key, KeyState, KeyModifiers),
    /// Changes the cursor.
-    SetCursor(Cursor),
+    SetCursor(CursorKind),
    /// A favicon was detected
    NewFavicon(TopLevelBrowsingContextId, ServoUrl),
    /// <head> tag finished parsing
--- a/components/compositing/windowing.rs
+++ b/components/compositing/windowing.rs
@ -17,7 +17,7 @@ use servo_url::ServoUrl;
 use std::fmt::{Debug, Error, Formatter};
 use std::rc::Rc;
 use style_traits::DevicePixel;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use webrender_api::{DeviceUintSize, DeviceUintRect, ScrollLocation};

 #[derive(Clone)]
@ -173,7 +173,7 @@ pub trait WindowMethods {
    fn prepare_for_composite(&self, width: usize, height: usize) -> bool;

    /// Sets the cursor to be used in the window.
-    fn set_cursor(&self, cursor: Cursor);
+    fn set_cursor(&self, cursor: CursorKind);

    /// Process a key event.
    fn handle_key(&self, ctx: Option<TopLevelBrowsingContextId>, ch: Option<char>, key: Key, mods: KeyModifiers);
--- a/components/constellation/constellation.rs
+++ b/components/constellation/constellation.rs
@ -152,7 +152,7 @@ use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::thread;
 use style_traits::CSSPixel;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use style_traits::viewport::ViewportConstraints;
 use timer_scheduler::TimerScheduler;
 use webrender_api;
@ -1806,7 +1806,7 @@ impl<Message, LTF, STF> Constellation<Message, LTF, STF>
        self.compositor_proxy.send(ToCompositorMsg::PendingPaintMetric(pipeline_id, epoch))
    }

-    fn handle_set_cursor_msg(&mut self, cursor: Cursor) {
+    fn handle_set_cursor_msg(&mut self, cursor: CursorKind) {
        self.embedder_proxy.send(EmbedderMsg::SetCursor(cursor))
    }

--- a/components/gfx/display_list/mod.rs
+++ b/components/gfx/display_list/mod.rs
@ -30,7 +30,7 @@ use std::f32;
 use std::fmt;
 use std::sync::Arc;
 use style::values::computed::Filter;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use text::TextRun;
 use text::glyph::ByteIndex;
 use webrender_api::{BoxShadowClipMode, ClipId, ColorF, ExtendMode, GradientStop, ImageKey};
@ -646,7 +646,7 @@ pub struct DisplayItemMetadata {
    pub node: OpaqueNode,
    /// The value of the `cursor` property when the mouse hovers over this display item. If `None`,
    /// this display item is ineligible for pointer events (`pointer-events: none`).
-    pub pointing: Option<Cursor>,
+    pub pointing: Option<CursorKind>,
 }

 /// Paints a solid color.
--- a/components/layout/display_list/builder.rs
+++ b/components/layout/display_list/builder.rs
@ -55,7 +55,6 @@ use style::computed_values::background_attachment::single_value::T as Background
 use style::computed_values::background_clip::single_value::T as BackgroundClip;
 use style::computed_values::background_origin::single_value::T as BackgroundOrigin;
 use style::computed_values::border_style::T as BorderStyle;
-use style::computed_values::cursor;
 use style::computed_values::overflow_x::T as StyleOverflow;
 use style::computed_values::pointer_events::T as PointerEvents;
 use style::computed_values::position::T as StylePosition;
@ -67,12 +66,13 @@ use style::servo::restyle_damage::ServoRestyleDamage;
 use style::values::{Either, RGBA};
 use style::values::computed::{Gradient, NumberOrPercentage};
 use style::values::computed::effects::SimpleShadow;
+use style::values::computed::pointing::Cursor;
 use style::values::generics::background::BackgroundSize;
 use style::values::generics::effects::Filter;
 use style::values::generics::image::{GradientKind, Image, PaintWorklet};
 use style_traits::CSSPixel;
 use style_traits::ToCss;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use table_cell::CollapsedBordersForCell;
 use webrender_api::{self, BoxShadowClipMode, ClipId, ClipMode, ColorF, ComplexClipRegion};
 use webrender_api::{ImageRendering, LayoutSize, LayoutVector2D, LineStyle};
@ -375,7 +375,7 @@ impl<'a> DisplayListBuildState<'a> {
        bounds: &Rect<Au>,
        clip: LocalClip,
        node: OpaqueNode,
-        cursor: Option<Cursor>,
+        cursor: Option<CursorKind>,
        section: DisplayListSection,
    ) -> BaseDisplayItem {
        let clipping_and_scrolling = if self.is_background_or_border_of_clip_scroll_node(section) {
@ -930,7 +930,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &bounds,
            clip,
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            display_list_section,
        );
        state.add_display_item(DisplayItem::SolidColor(Box::new(SolidColorDisplayItem {
@ -1121,7 +1121,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &placement.bounds,
            LocalClip::Rect(placement.css_clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            display_list_section,
        );

@ -1213,7 +1213,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &placement.bounds,
            LocalClip::Rect(placement.css_clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            display_list_section,
        );

@ -1274,7 +1274,7 @@ impl FragmentDisplayListBuilding for Fragment {
                &bounds,
                LocalClip::from(clip.to_layout()),
                self.node,
-                style.get_cursor(Cursor::Default),
+                style.get_cursor(CursorKind::Default),
                display_list_section,
            );
            let border_radius = build_border_radius(absolute_bounds, style.get_border());
@ -1370,7 +1370,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &bounds,
            LocalClip::from(clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            display_list_section,
        );

@ -1544,7 +1544,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &bounds,
            LocalClip::from(clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            DisplayListSection::Outlines,
        );
        state.add_display_item(DisplayItem::Border(Box::new(BorderDisplayItem {
@ -1571,7 +1571,7 @@ impl FragmentDisplayListBuilding for Fragment {
            stacking_relative_border_box,
            LocalClip::from(clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            DisplayListSection::Content,
        );
        state.add_display_item(DisplayItem::Border(Box::new(BorderDisplayItem {
@ -1597,7 +1597,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &baseline,
            LocalClip::from(clip.to_layout()),
            self.node,
-            style.get_cursor(Cursor::Default),
+            style.get_cursor(CursorKind::Default),
            DisplayListSection::Content,
        );
        state.add_display_item(DisplayItem::Line(Box::new(LineDisplayItem {
@ -1618,7 +1618,7 @@ impl FragmentDisplayListBuilding for Fragment {
            stacking_relative_border_box,
            LocalClip::from(clip.to_layout()),
            self.node,
-            self.style.get_cursor(Cursor::Default),
+            self.style.get_cursor(CursorKind::Default),
            DisplayListSection::Content,
        );
        state.add_display_item(DisplayItem::Border(Box::new(BorderDisplayItem {
@ -1655,7 +1655,7 @@ impl FragmentDisplayListBuilding for Fragment {
                stacking_relative_border_box,
                LocalClip::from(clip.to_layout()),
                self.node,
-                self.style.get_cursor(Cursor::Default),
+                self.style.get_cursor(CursorKind::Default),
                display_list_section,
            );
            state.add_display_item(DisplayItem::SolidColor(Box::new(SolidColorDisplayItem {
@ -1688,7 +1688,7 @@ impl FragmentDisplayListBuilding for Fragment {
                    stacking_relative_border_box.size.height,
                ),
            );
-            cursor = Cursor::Text;
+            cursor = CursorKind::Text;
        } else {
            insertion_point_bounds = Rect::new(
                Point2D::new(
@ -1700,7 +1700,7 @@ impl FragmentDisplayListBuilding for Fragment {
                    INSERTION_POINT_LOGICAL_WIDTH,
                ),
            );
-            cursor = Cursor::VerticalText;
+            cursor = CursorKind::VerticalText;
        };

        let base = state.create_base_display_item(
@ -1963,7 +1963,7 @@ impl FragmentDisplayListBuilding for Fragment {
                        &stacking_relative_content_box,
                        build_local_clip(&self.style),
                        self.node,
-                        self.style.get_cursor(Cursor::Default),
+                        self.style.get_cursor(CursorKind::Default),
                        DisplayListSection::Content,
                    );
                    let item = DisplayItem::Iframe(Box::new(IframeDisplayItem {
@ -1989,7 +1989,7 @@ impl FragmentDisplayListBuilding for Fragment {
                        &stacking_relative_content_box,
                        build_local_clip(&self.style),
                        self.node,
-                        self.style.get_cursor(Cursor::Default),
+                        self.style.get_cursor(CursorKind::Default),
                        DisplayListSection::Content,
                    );
                    state.add_display_item(DisplayItem::Image(Box::new(ImageDisplayItem {
@ -2025,7 +2025,7 @@ impl FragmentDisplayListBuilding for Fragment {
                    &stacking_relative_content_box,
                    build_local_clip(&self.style),
                    self.node,
-                    self.style.get_cursor(Cursor::Default),
+                    self.style.get_cursor(CursorKind::Default),
                    DisplayListSection::Content,
                );
                let display_item = DisplayItem::Image(Box::new(ImageDisplayItem {
@ -2128,9 +2128,9 @@ impl FragmentDisplayListBuilding for Fragment {
        let (orientation, cursor) = if self.style.writing_mode.is_vertical() {
            // TODO: Distinguish between 'sideways-lr' and 'sideways-rl' writing modes in CSS
            // Writing Modes Level 4.
-            (TextOrientation::SidewaysRight, Cursor::VerticalText)
+            (TextOrientation::SidewaysRight, CursorKind::VerticalText)
        } else {
-            (TextOrientation::Upright, Cursor::Text)
+            (TextOrientation::Upright, CursorKind::Text)
        };

        // Compute location of the baseline.
@ -2256,7 +2256,7 @@ impl FragmentDisplayListBuilding for Fragment {
            &stacking_relative_box,
            LocalClip::from(clip.to_layout()),
            self.node,
-            self.style.get_cursor(Cursor::Default),
+            self.style.get_cursor(CursorKind::Default),
            DisplayListSection::Content,
        );

@ -3158,7 +3158,7 @@ impl BaseFlowDisplayListBuilding for BaseFlow {
 }

 trait ComputedValuesCursorUtility {
-    fn get_cursor(&self, default_cursor: Cursor) -> Option<Cursor>;
+    fn get_cursor(&self, default_cursor: CursorKind) -> Option<CursorKind>;
 }

 impl ComputedValuesCursorUtility for ComputedValues {
@ -3166,14 +3166,14 @@ impl ComputedValuesCursorUtility for ComputedValues {
    /// the cursor to use if `cursor` is `auto`. Typically, this will be `PointerCursor`, but for
    /// text display items it may be `TextCursor` or `VerticalTextCursor`.
    #[inline]
-    fn get_cursor(&self, default_cursor: Cursor) -> Option<Cursor> {
+    fn get_cursor(&self, default_cursor: CursorKind) -> Option<CursorKind> {
        match (
            self.get_pointing().pointer_events,
            self.get_pointing().cursor,
        ) {
            (PointerEvents::None, _) => None,
-            (PointerEvents::Auto, cursor::Keyword::Auto) => Some(default_cursor),
-            (PointerEvents::Auto, cursor::Keyword::Cursor(cursor)) => Some(cursor),
+            (PointerEvents::Auto, Cursor(CursorKind::Auto)) => Some(default_cursor),
+            (PointerEvents::Auto, Cursor(cursor)) => Some(cursor),
        }
    }
 }
--- a/components/script_traits/lib.rs
+++ b/components/script_traits/lib.rs
@ -68,7 +68,7 @@ use std::sync::Arc;
 use std::sync::mpsc::{Receiver, Sender, RecvTimeoutError};
 use style_traits::CSSPixel;
 use style_traits::SpeculativePainter;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use webdriver_msg::{LoadStatus, WebDriverScriptCommand};
 use webrender_api::{ClipId, DevicePixel, DocumentId, ImageKey};
 use webvr_traits::{WebVREvent, WebVRMsg};
@ -807,7 +807,7 @@ pub enum ConstellationMsg {
    /// Forward an event to the script task of the given pipeline.
    ForwardEvent(PipelineId, CompositorEvent),
    /// Requesting a change to the onscreen cursor.
-    SetCursor(Cursor),
+    SetCursor(CursorKind),
 }

 /// Resources required by workerglobalscopes
--- a/components/script_traits/script_msg.rs
+++ b/components/script_traits/script_msg.rs
@ -25,7 +25,7 @@ use net_traits::storage_thread::StorageType;
 use servo_url::ImmutableOrigin;
 use servo_url::ServoUrl;
 use style_traits::CSSPixel;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use style_traits::viewport::ViewportConstraints;

 /// Messages from the layout to the constellation.
@ -39,7 +39,7 @@ pub enum LayoutMsg {
    /// the time when the frame with the given ID (epoch) is painted.
    PendingPaintMetric(PipelineId, Epoch),
    /// Requests that the constellation inform the compositor of the a cursor change.
-    SetCursor(Cursor),
+    SetCursor(CursorKind),
    /// Notifies the constellation that the viewport has been constrained in some manner
    ViewportConstrained(PipelineId, ViewportConstraints),
 }
--- a/components/style/properties/gecko.mako.rs
+++ b/components/style/properties/gecko.mako.rs
@ -5302,53 +5302,50 @@ clip-path
 <%self:impl_trait style_struct_name="Pointing"
                  skip_longhands="cursor caret-color">
    pub fn set_cursor(&mut self, v: longhands::cursor::computed_value::T) {
-        use properties::longhands::cursor::computed_value::Keyword;
-        use style_traits::cursor::Cursor;
+        use style_traits::cursor::CursorKind;

        self.gecko.mCursor = match v.keyword {
-            Keyword::Auto => structs::NS_STYLE_CURSOR_AUTO,
-            Keyword::Cursor(cursor) => match cursor {
-                Cursor::None => structs::NS_STYLE_CURSOR_NONE,
-                Cursor::Default => structs::NS_STYLE_CURSOR_DEFAULT,
-                Cursor::Pointer => structs::NS_STYLE_CURSOR_POINTER,
-                Cursor::ContextMenu => structs::NS_STYLE_CURSOR_CONTEXT_MENU,
-                Cursor::Help => structs::NS_STYLE_CURSOR_HELP,
-                Cursor::Progress => structs::NS_STYLE_CURSOR_SPINNING,
-                Cursor::Wait => structs::NS_STYLE_CURSOR_WAIT,
-                Cursor::Cell => structs::NS_STYLE_CURSOR_CELL,
-                Cursor::Crosshair => structs::NS_STYLE_CURSOR_CROSSHAIR,
-                Cursor::Text => structs::NS_STYLE_CURSOR_TEXT,
-                Cursor::VerticalText => structs::NS_STYLE_CURSOR_VERTICAL_TEXT,
-                Cursor::Alias => structs::NS_STYLE_CURSOR_ALIAS,
-                Cursor::Copy => structs::NS_STYLE_CURSOR_COPY,
-                Cursor::Move => structs::NS_STYLE_CURSOR_MOVE,
-                Cursor::NoDrop => structs::NS_STYLE_CURSOR_NO_DROP,
-                Cursor::NotAllowed => structs::NS_STYLE_CURSOR_NOT_ALLOWED,
-                Cursor::Grab => structs::NS_STYLE_CURSOR_GRAB,
-                Cursor::Grabbing => structs::NS_STYLE_CURSOR_GRABBING,
-                Cursor::EResize => structs::NS_STYLE_CURSOR_E_RESIZE,
-                Cursor::NResize => structs::NS_STYLE_CURSOR_N_RESIZE,
-                Cursor::NeResize => structs::NS_STYLE_CURSOR_NE_RESIZE,
-                Cursor::NwResize => structs::NS_STYLE_CURSOR_NW_RESIZE,
-                Cursor::SResize => structs::NS_STYLE_CURSOR_S_RESIZE,
-                Cursor::SeResize => structs::NS_STYLE_CURSOR_SE_RESIZE,
-                Cursor::SwResize => structs::NS_STYLE_CURSOR_SW_RESIZE,
-                Cursor::WResize => structs::NS_STYLE_CURSOR_W_RESIZE,
-                Cursor::EwResize => structs::NS_STYLE_CURSOR_EW_RESIZE,
-                Cursor::NsResize => structs::NS_STYLE_CURSOR_NS_RESIZE,
-                Cursor::NeswResize => structs::NS_STYLE_CURSOR_NESW_RESIZE,
-                Cursor::NwseResize => structs::NS_STYLE_CURSOR_NWSE_RESIZE,
-                Cursor::ColResize => structs::NS_STYLE_CURSOR_COL_RESIZE,
-                Cursor::RowResize => structs::NS_STYLE_CURSOR_ROW_RESIZE,
-                Cursor::AllScroll => structs::NS_STYLE_CURSOR_ALL_SCROLL,
-                Cursor::ZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
-                Cursor::ZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
-                // note: the following properties are gecko-only.
-                Cursor::MozGrab => structs::NS_STYLE_CURSOR_GRAB,
-                Cursor::MozGrabbing => structs::NS_STYLE_CURSOR_GRABBING,
-                Cursor::MozZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
-                Cursor::MozZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
-            }
+            CursorKind::Auto => structs::NS_STYLE_CURSOR_AUTO,
+            CursorKind::None => structs::NS_STYLE_CURSOR_NONE,
+            CursorKind::Default => structs::NS_STYLE_CURSOR_DEFAULT,
+            CursorKind::Pointer => structs::NS_STYLE_CURSOR_POINTER,
+            CursorKind::ContextMenu => structs::NS_STYLE_CURSOR_CONTEXT_MENU,
+            CursorKind::Help => structs::NS_STYLE_CURSOR_HELP,
+            CursorKind::Progress => structs::NS_STYLE_CURSOR_SPINNING,
+            CursorKind::Wait => structs::NS_STYLE_CURSOR_WAIT,
+            CursorKind::Cell => structs::NS_STYLE_CURSOR_CELL,
+            CursorKind::Crosshair => structs::NS_STYLE_CURSOR_CROSSHAIR,
+            CursorKind::Text => structs::NS_STYLE_CURSOR_TEXT,
+            CursorKind::VerticalText => structs::NS_STYLE_CURSOR_VERTICAL_TEXT,
+            CursorKind::Alias => structs::NS_STYLE_CURSOR_ALIAS,
+            CursorKind::Copy => structs::NS_STYLE_CURSOR_COPY,
+            CursorKind::Move => structs::NS_STYLE_CURSOR_MOVE,
+            CursorKind::NoDrop => structs::NS_STYLE_CURSOR_NO_DROP,
+            CursorKind::NotAllowed => structs::NS_STYLE_CURSOR_NOT_ALLOWED,
+            CursorKind::Grab => structs::NS_STYLE_CURSOR_GRAB,
+            CursorKind::Grabbing => structs::NS_STYLE_CURSOR_GRABBING,
+            CursorKind::EResize => structs::NS_STYLE_CURSOR_E_RESIZE,
+            CursorKind::NResize => structs::NS_STYLE_CURSOR_N_RESIZE,
+            CursorKind::NeResize => structs::NS_STYLE_CURSOR_NE_RESIZE,
+            CursorKind::NwResize => structs::NS_STYLE_CURSOR_NW_RESIZE,
+            CursorKind::SResize => structs::NS_STYLE_CURSOR_S_RESIZE,
+            CursorKind::SeResize => structs::NS_STYLE_CURSOR_SE_RESIZE,
+            CursorKind::SwResize => structs::NS_STYLE_CURSOR_SW_RESIZE,
+            CursorKind::WResize => structs::NS_STYLE_CURSOR_W_RESIZE,
+            CursorKind::EwResize => structs::NS_STYLE_CURSOR_EW_RESIZE,
+            CursorKind::NsResize => structs::NS_STYLE_CURSOR_NS_RESIZE,
+            CursorKind::NeswResize => structs::NS_STYLE_CURSOR_NESW_RESIZE,
+            CursorKind::NwseResize => structs::NS_STYLE_CURSOR_NWSE_RESIZE,
+            CursorKind::ColResize => structs::NS_STYLE_CURSOR_COL_RESIZE,
+            CursorKind::RowResize => structs::NS_STYLE_CURSOR_ROW_RESIZE,
+            CursorKind::AllScroll => structs::NS_STYLE_CURSOR_ALL_SCROLL,
+            CursorKind::ZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
+            CursorKind::ZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
+            // note: the following properties are gecko-only.
+            CursorKind::MozGrab => structs::NS_STYLE_CURSOR_GRAB,
+            CursorKind::MozGrabbing => structs::NS_STYLE_CURSOR_GRABBING,
+            CursorKind::MozZoomIn => structs::NS_STYLE_CURSOR_ZOOM_IN,
+            CursorKind::MozZoomOut => structs::NS_STYLE_CURSOR_ZOOM_OUT,
        } as u8;

        unsafe {
@ -5390,47 +5387,47 @@ clip-path
    }

    pub fn clone_cursor(&self) -> longhands::cursor::computed_value::T {
-        use properties::longhands::cursor::computed_value::{Keyword, Image};
-        use style_traits::cursor::Cursor;
+        use values::computed::pointing::CursorImage;
+        use style_traits::cursor::CursorKind;
        use values::specified::url::SpecifiedUrl;

        let keyword = match self.gecko.mCursor as u32 {
-            structs::NS_STYLE_CURSOR_AUTO => Keyword::Auto,
-            structs::NS_STYLE_CURSOR_NONE => Keyword::Cursor(Cursor::None),
-            structs::NS_STYLE_CURSOR_DEFAULT => Keyword::Cursor(Cursor::Default),
-            structs::NS_STYLE_CURSOR_POINTER => Keyword::Cursor(Cursor::Pointer),
-            structs::NS_STYLE_CURSOR_CONTEXT_MENU => Keyword::Cursor(Cursor::ContextMenu),
-            structs::NS_STYLE_CURSOR_HELP => Keyword::Cursor(Cursor::Help),
-            structs::NS_STYLE_CURSOR_SPINNING => Keyword::Cursor(Cursor::Progress),
-            structs::NS_STYLE_CURSOR_WAIT => Keyword::Cursor(Cursor::Wait),
-            structs::NS_STYLE_CURSOR_CELL => Keyword::Cursor(Cursor::Cell),
-            structs::NS_STYLE_CURSOR_CROSSHAIR => Keyword::Cursor(Cursor::Crosshair),
-            structs::NS_STYLE_CURSOR_TEXT => Keyword::Cursor(Cursor::Text),
-            structs::NS_STYLE_CURSOR_VERTICAL_TEXT => Keyword::Cursor(Cursor::VerticalText),
-            structs::NS_STYLE_CURSOR_ALIAS => Keyword::Cursor(Cursor::Alias),
-            structs::NS_STYLE_CURSOR_COPY => Keyword::Cursor(Cursor::Copy),
-            structs::NS_STYLE_CURSOR_MOVE => Keyword::Cursor(Cursor::Move),
-            structs::NS_STYLE_CURSOR_NO_DROP => Keyword::Cursor(Cursor::NoDrop),
-            structs::NS_STYLE_CURSOR_NOT_ALLOWED => Keyword::Cursor(Cursor::NotAllowed),
-            structs::NS_STYLE_CURSOR_GRAB => Keyword::Cursor(Cursor::Grab),
-            structs::NS_STYLE_CURSOR_GRABBING => Keyword::Cursor(Cursor::Grabbing),
-            structs::NS_STYLE_CURSOR_E_RESIZE => Keyword::Cursor(Cursor::EResize),
-            structs::NS_STYLE_CURSOR_N_RESIZE => Keyword::Cursor(Cursor::NResize),
-            structs::NS_STYLE_CURSOR_NE_RESIZE => Keyword::Cursor(Cursor::NeResize),
-            structs::NS_STYLE_CURSOR_NW_RESIZE => Keyword::Cursor(Cursor::NwResize),
-            structs::NS_STYLE_CURSOR_S_RESIZE => Keyword::Cursor(Cursor::SResize),
-            structs::NS_STYLE_CURSOR_SE_RESIZE => Keyword::Cursor(Cursor::SeResize),
-            structs::NS_STYLE_CURSOR_SW_RESIZE => Keyword::Cursor(Cursor::SwResize),
-            structs::NS_STYLE_CURSOR_W_RESIZE => Keyword::Cursor(Cursor::WResize),
-            structs::NS_STYLE_CURSOR_EW_RESIZE => Keyword::Cursor(Cursor::EwResize),
-            structs::NS_STYLE_CURSOR_NS_RESIZE => Keyword::Cursor(Cursor::NsResize),
-            structs::NS_STYLE_CURSOR_NESW_RESIZE => Keyword::Cursor(Cursor::NeswResize),
-            structs::NS_STYLE_CURSOR_NWSE_RESIZE => Keyword::Cursor(Cursor::NwseResize),
-            structs::NS_STYLE_CURSOR_COL_RESIZE => Keyword::Cursor(Cursor::ColResize),
-            structs::NS_STYLE_CURSOR_ROW_RESIZE => Keyword::Cursor(Cursor::RowResize),
-            structs::NS_STYLE_CURSOR_ALL_SCROLL => Keyword::Cursor(Cursor::AllScroll),
-            structs::NS_STYLE_CURSOR_ZOOM_IN => Keyword::Cursor(Cursor::ZoomIn),
-            structs::NS_STYLE_CURSOR_ZOOM_OUT => Keyword::Cursor(Cursor::ZoomOut),
+            structs::NS_STYLE_CURSOR_AUTO => CursorKind::Auto,
+            structs::NS_STYLE_CURSOR_NONE => CursorKind::None,
+            structs::NS_STYLE_CURSOR_DEFAULT => CursorKind::Default,
+            structs::NS_STYLE_CURSOR_POINTER => CursorKind::Pointer,
+            structs::NS_STYLE_CURSOR_CONTEXT_MENU => CursorKind::ContextMenu,
+            structs::NS_STYLE_CURSOR_HELP => CursorKind::Help,
+            structs::NS_STYLE_CURSOR_SPINNING => CursorKind::Progress,
+            structs::NS_STYLE_CURSOR_WAIT => CursorKind::Wait,
+            structs::NS_STYLE_CURSOR_CELL => CursorKind::Cell,
+            structs::NS_STYLE_CURSOR_CROSSHAIR => CursorKind::Crosshair,
+            structs::NS_STYLE_CURSOR_TEXT => CursorKind::Text,
+            structs::NS_STYLE_CURSOR_VERTICAL_TEXT => CursorKind::VerticalText,
+            structs::NS_STYLE_CURSOR_ALIAS => CursorKind::Alias,
+            structs::NS_STYLE_CURSOR_COPY => CursorKind::Copy,
+            structs::NS_STYLE_CURSOR_MOVE => CursorKind::Move,
+            structs::NS_STYLE_CURSOR_NO_DROP => CursorKind::NoDrop,
+            structs::NS_STYLE_CURSOR_NOT_ALLOWED => CursorKind::NotAllowed,
+            structs::NS_STYLE_CURSOR_GRAB => CursorKind::Grab,
+            structs::NS_STYLE_CURSOR_GRABBING => CursorKind::Grabbing,
+            structs::NS_STYLE_CURSOR_E_RESIZE => CursorKind::EResize,
+            structs::NS_STYLE_CURSOR_N_RESIZE => CursorKind::NResize,
+            structs::NS_STYLE_CURSOR_NE_RESIZE => CursorKind::NeResize,
+            structs::NS_STYLE_CURSOR_NW_RESIZE => CursorKind::NwResize,
+            structs::NS_STYLE_CURSOR_S_RESIZE => CursorKind::SResize,
+            structs::NS_STYLE_CURSOR_SE_RESIZE => CursorKind::SeResize,
+            structs::NS_STYLE_CURSOR_SW_RESIZE => CursorKind::SwResize,
+            structs::NS_STYLE_CURSOR_W_RESIZE => CursorKind::WResize,
+            structs::NS_STYLE_CURSOR_EW_RESIZE => CursorKind::EwResize,
+            structs::NS_STYLE_CURSOR_NS_RESIZE => CursorKind::NsResize,
+            structs::NS_STYLE_CURSOR_NESW_RESIZE => CursorKind::NeswResize,
+            structs::NS_STYLE_CURSOR_NWSE_RESIZE => CursorKind::NwseResize,
+            structs::NS_STYLE_CURSOR_COL_RESIZE => CursorKind::ColResize,
+            structs::NS_STYLE_CURSOR_ROW_RESIZE => CursorKind::RowResize,
+            structs::NS_STYLE_CURSOR_ALL_SCROLL => CursorKind::AllScroll,
+            structs::NS_STYLE_CURSOR_ZOOM_IN => CursorKind::ZoomIn,
+            structs::NS_STYLE_CURSOR_ZOOM_OUT => CursorKind::ZoomOut,
            _ => panic!("Found unexpected value in style struct for cursor property"),
        };

@ -5448,8 +5445,8 @@ clip-path
                    None
                };

-            Image { url, hotspot }
-        }).collect();
+            CursorImage { url, hotspot }
+        }).collect::<Vec<_>>().into_boxed_slice();

        longhands::cursor::computed_value::T { images, keyword }
    }
--- a/components/style/properties/longhand/pointing.mako.rs
+++ b/components/style/properties/longhand/pointing.mako.rs
@ -6,142 +6,12 @@

 <% data.new_style_struct("Pointing", inherited=True, gecko_name="UserInterface") %>

-<%helpers:longhand name="cursor" boxed="${product == 'gecko'}" animation_value_type="discrete"
-  spec="https://drafts.csswg.org/css-ui/#cursor">
-    pub use self::computed_value::T as SpecifiedValue;
-    #[cfg(feature = "gecko")]
-    use values::specified::url::SpecifiedUrl;
-
-    pub mod computed_value {
-        #[cfg(feature = "gecko")]
-        use std::fmt;
-        #[cfg(feature = "gecko")]
-        use style_traits::ToCss;
-        use style_traits::cursor::Cursor;
-        #[cfg(feature = "gecko")]
-        use values::specified::url::SpecifiedUrl;
-
-        #[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
-        pub enum Keyword {
-            Auto,
-            Cursor(Cursor),
-        }
-
-        #[cfg(not(feature = "gecko"))]
-        pub type T = Keyword;
-
-        #[cfg(feature = "gecko")]
-        #[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
-        pub struct Image {
-            pub url: SpecifiedUrl,
-            pub hotspot: Option<(f32, f32)>,
-        }
-
-        #[cfg(feature = "gecko")]
-        #[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
-        pub struct T {
-            pub images: Vec<Image>,
-            pub keyword: Keyword,
-        }
-
-        #[cfg(feature = "gecko")]
-        impl ToCss for Image {
-            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                self.url.to_css(dest)?;
-                if let Some((x, y)) = self.hotspot {
-                    dest.write_str(" ")?;
-                    x.to_css(dest)?;
-                    dest.write_str(" ")?;
-                    y.to_css(dest)?;
-                }
-                Ok(())
-            }
-        }
-
-        #[cfg(feature = "gecko")]
-        impl ToCss for T {
-            fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
-                for url in &self.images {
-                    url.to_css(dest)?;
-                    dest.write_str(", ")?;
-                }
-                self.keyword.to_css(dest)
-            }
-        }
-    }
-
-    #[cfg(not(feature = "gecko"))]
-    #[inline]
-    pub fn get_initial_value() -> computed_value::T {
-        computed_value::Keyword::Auto
-    }
-
-    #[cfg(feature = "gecko")]
-    #[inline]
-    pub fn get_initial_value() -> computed_value::T {
-        computed_value::T {
-            images: vec![],
-            keyword: computed_value::Keyword::Auto
-        }
-    }
-
-    impl Parse for computed_value::Keyword {
-        fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
-                         -> Result<computed_value::Keyword, ParseError<'i>> {
-            #[allow(unused_imports)] use std::ascii::AsciiExt;
-            use style_traits::cursor::Cursor;
-            let location = input.current_source_location();
-            let ident = input.expect_ident()?;
-            if ident.eq_ignore_ascii_case("auto") {
-                Ok(computed_value::Keyword::Auto)
-            } else {
-                Cursor::from_css_keyword(&ident)
-                    .map(computed_value::Keyword::Cursor)
-                    .map_err(|()| location.new_custom_error(SelectorParseErrorKind::UnexpectedIdent(ident.clone())))
-            }
-        }
-    }
-
-    #[cfg(feature = "gecko")]
-    fn parse_image<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-                           -> Result<computed_value::Image, ParseError<'i>> {
-        Ok(computed_value::Image {
-            url: SpecifiedUrl::parse(context, input)?,
-            hotspot: match input.try(|input| input.expect_number()) {
-                Ok(number) => Some((number, input.expect_number()?)),
-                Err(_) => None,
-            },
-        })
-    }
-
-    #[cfg(not(feature = "gecko"))]
-    pub fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-                         -> Result<SpecifiedValue, ParseError<'i>> {
-        computed_value::Keyword::parse(context, input)
-    }
-
-    /// cursor: [<url> [<number> <number>]?]# [auto | default | ...]
-    #[cfg(feature = "gecko")]
-    pub fn parse<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-                         -> Result<SpecifiedValue, ParseError<'i>> {
-        let mut images = vec![];
-        loop {
-            match input.try(|input| parse_image(context, input)) {
-                Ok(mut image) => {
-                    image.url.build_image_value();
-                    images.push(image)
-                }
-                Err(_) => break,
-            }
-            input.expect_comma()?;
-        }
-
-        Ok(computed_value::T {
-            images: images,
-            keyword: computed_value::Keyword::parse(context, input)?,
-        })
-    }
-</%helpers:longhand>
+${helpers.predefined_type("cursor",
+                          "Cursor",
+                          "computed::Cursor::auto()",
+                          initial_specified_value="specified::Cursor::auto()",
+                          animation_value_type="discrete",
+                          spec="https://drafts.csswg.org/css-ui/#cursor")}

 // NB: `pointer-events: auto` (and use of `pointer-events` in anything that isn't SVG, in fact)
 // is nonstandard, slated for CSS4-UI.
--- a/components/style/values/computed/mod.rs
+++ b/components/style/values/computed/mod.rs
@ -20,7 +20,7 @@ use std::cell::RefCell;
 #[cfg(feature = "servo")]
 use std::sync::Arc;
 use style_traits::ToCss;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use super::{CSSFloat, CSSInteger};
 use super::generics::{GreaterThanOrEqualToOne, NonNegative};
 use super::generics::grid::{GridLine as GenericGridLine, TrackBreadth as GenericTrackBreadth};
@ -61,6 +61,9 @@ pub use self::list::ListStyleType;
 pub use self::outline::OutlineStyle;
 pub use self::percentage::Percentage;
 pub use self::position::{Position, GridAutoFlow, GridTemplateAreas};
+pub use self::pointing::Cursor;
+#[cfg(feature = "gecko")]
+pub use self::pointing::CursorImage;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint, SVGPaintKind};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
 pub use self::svg::MozContextProperties;
@ -90,6 +93,7 @@ pub mod length;
 pub mod list;
 pub mod outline;
 pub mod percentage;
+pub mod pointing;
 pub mod position;
 pub mod rect;
 pub mod svg;
@ -404,7 +408,7 @@ trivial_to_computed_value!(u16);
 trivial_to_computed_value!(u32);
 trivial_to_computed_value!(Atom);
 trivial_to_computed_value!(BorderStyle);
-trivial_to_computed_value!(Cursor);
+trivial_to_computed_value!(CursorKind);
 trivial_to_computed_value!(Namespace);
 trivial_to_computed_value!(String);
 trivial_to_computed_value!(Box<str>);
--- a/components/style/values/computed/pointing.rs
+++ b/components/style/values/computed/pointing.rs
@ -0,0 +1,138 @@
+/* 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/. */
+
+//! Computed values for Pointing properties.
+//!
+//! https://drafts.csswg.org/css-ui/#pointing-keyboard
+
+use cssparser::Parser;
+use parser::{Parse, ParserContext};
+use selectors::parser::SelectorParseErrorKind;
+#[cfg(feature = "gecko")]
+use std::fmt;
+use style_traits::ParseError;
+#[cfg(feature = "gecko")]
+use style_traits::ToCss;
+use style_traits::cursor::CursorKind;
+
+/// The computed value for the `cursor` property.
+///
+/// https://drafts.csswg.org/css-ui/#cursor
+pub use values::specified::pointing::Cursor;
+#[cfg(feature = "gecko")]
+pub use values::specified::pointing::CursorImage;
+#[cfg(feature = "gecko")]
+use values::specified::url::SpecifiedUrl;
+
+impl Cursor {
+    /// Set `cursor` to `auto`
+    #[cfg(feature = "servo")]
+    #[inline]
+    pub fn auto() -> Self {
+        Cursor(CursorKind::Auto)
+    }
+
+    /// Set `cursor` to `auto`
+    #[cfg(feature = "gecko")]
+    #[inline]
+    pub fn auto() -> Self {
+        Self {
+            images: vec![].into_boxed_slice(),
+            keyword: CursorKind::Auto
+        }
+    }
+}
+
+impl Parse for Cursor {
+    /// cursor: [auto | default | ...]
+    #[cfg(feature = "servo")]
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<Self, ParseError<'i>> {
+        Ok(Cursor(CursorKind::parse(context, input)?))
+    }
+
+    /// cursor: [<url> [<number> <number>]?]# [auto | default | ...]
+    #[cfg(feature = "gecko")]
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<Self, ParseError<'i>> {
+        let mut images = vec![];
+        loop {
+            match input.try(|input| CursorImage::parse_image(context, input)) {
+                Ok(mut image) => {
+                    image.url.build_image_value();
+                    images.push(image)
+                }
+                Err(_) => break,
+            }
+            input.expect_comma()?;
+        }
+        Ok(Self {
+            images: images.into_boxed_slice(),
+            keyword: CursorKind::parse(context, input)?,
+        })
+    }
+}
+
+#[cfg(feature = "gecko")]
+impl ToCss for Cursor {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+        where W: fmt::Write
+    {
+        for url in &*self.images {
+            url.to_css(dest)?;
+            dest.write_str(", ")?;
+        }
+        self.keyword.to_css(dest)
+    }
+}
+
+impl Parse for CursorKind {
+    fn parse<'i, 't>(
+        _context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<Self, ParseError<'i>> {
+        let location = input.current_source_location();
+        let ident = input.expect_ident()?;
+        CursorKind::from_css_keyword(&ident)
+            .map_err(|_| location.new_custom_error(
+                    SelectorParseErrorKind::UnexpectedIdent(ident.clone())))
+    }
+}
+
+#[cfg(feature = "gecko")]
+impl CursorImage {
+    fn parse_image<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<Self, ParseError<'i>> {
+        Ok(Self {
+            url: SpecifiedUrl::parse(context, input)?,
+            // FIXME(emilio): Should use Number::parse to handle calc() correctly.
+            hotspot: match input.try(|input| input.expect_number()) {
+                Ok(number) => Some((number, input.expect_number()?)),
+                Err(_) => None,
+            },
+        })
+    }
+}
+
+#[cfg(feature = "gecko")]
+impl ToCss for CursorImage {
+    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
+        where W: fmt::Write
+    {
+        self.url.to_css(dest)?;
+        if let Some((x, y)) = self.hotspot {
+            dest.write_str(" ")?;
+            x.to_css(dest)?;
+            dest.write_str(" ")?;
+            y.to_css(dest)?;
+        }
+        Ok(())
+    }
+}
--- a/components/style/values/specified/mod.rs
+++ b/components/style/values/specified/mod.rs
@ -57,6 +57,9 @@ pub use self::outline::OutlineStyle;
 pub use self::rect::LengthOrNumberRect;
 pub use self::percentage::Percentage;
 pub use self::position::{Position, PositionComponent, GridAutoFlow, GridTemplateAreas};
+pub use self::pointing::Cursor;
+#[cfg(feature = "gecko")]
+pub use self::pointing::CursorImage;
 pub use self::svg::{SVGLength, SVGOpacity, SVGPaint, SVGPaintKind};
 pub use self::svg::{SVGPaintOrder, SVGStrokeDashArray, SVGWidth};
 pub use self::svg::MozContextProperties;
@ -90,6 +93,7 @@ pub mod length;
 pub mod list;
 pub mod outline;
 pub mod percentage;
+pub mod pointing;
 pub mod position;
 pub mod rect;
 pub mod source_size_list;
--- a/components/style/values/specified/pointing.rs
+++ b/components/style/values/specified/pointing.rs
@ -0,0 +1,40 @@
+/* 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/. */
+
+//! Specified values for Pointing properties.
+//!
+//! https://drafts.csswg.org/css-ui/#pointing-keyboard
+
+use style_traits::cursor::CursorKind;
+#[cfg(feature = "gecko")]
+use values::specified::url::SpecifiedUrl;
+
+/// The specified value for the `cursor` property.
+///
+/// https://drafts.csswg.org/css-ui/#cursor
+#[cfg(feature = "servo")]
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToComputedValue, ToCss)]
+pub struct Cursor(pub CursorKind);
+
+/// The specified value for the `cursor` property.
+///
+/// https://drafts.csswg.org/css-ui/#cursor
+#[cfg(feature = "gecko")]
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
+pub struct Cursor {
+    /// The parsed images for the cursor.
+    pub images: Box<[CursorImage]>,
+    /// The kind of the cursor [default | help | ...].
+    pub keyword: CursorKind,
+}
+
+/// The specified value for the `image cursors`.
+#[cfg(feature = "gecko")]
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
+pub struct CursorImage {
+    /// The url to parse images from.
+    pub url: SpecifiedUrl,
+    /// The <x> and <y> coordinates.
+    pub hotspot: Option<(f32, f32)>,
+}
--- a/components/style_traits/cursor.rs
+++ b/components/style_traits/cursor.rs
@ -20,43 +20,42 @@ macro_rules! define_cursor {
        #[cfg_attr(feature = "servo", derive(Deserialize, Serialize))]
        #[repr(u8)]
        #[allow(missing_docs)]
-        pub enum Cursor {
+        pub enum CursorKind {
            $( $c_variant = $c_value, )+
            $( #[cfg(feature = "gecko")] $g_variant = $g_value, )+
        }

-        impl Cursor {
+        impl CursorKind {
            /// Given a CSS keyword, get the corresponding cursor enum.
-            pub fn from_css_keyword(keyword: &str) -> Result<Cursor, ()> {
+            pub fn from_css_keyword(keyword: &str) -> Result<Self, ()> {
                match_ignore_ascii_case! { &keyword,
-                    $( $c_css => Ok(Cursor::$c_variant), )+
-                    $( #[cfg(feature = "gecko")] $g_css => Ok(Cursor::$g_variant), )+
+                    $( $c_css => Ok(CursorKind::$c_variant), )+
+                    $( #[cfg(feature = "gecko")] $g_css => Ok(CursorKind::$g_variant), )+
                    _ => Err(())
                }
            }

            /// From the C u8 value, get the corresponding Cursor enum.
-            pub fn from_u8(value: u8) -> Result<Cursor, ()> {
+            pub fn from_u8(value: u8) -> Result<Self, ()> {
                match value {
-                    $( $c_value => Ok(Cursor::$c_variant), )+
-                    $( #[cfg(feature = "gecko")] $g_value => Ok(Cursor::$g_variant), )+
+                    $( $c_value => Ok(CursorKind::$c_variant), )+
+                    $( #[cfg(feature = "gecko")] $g_value => Ok(CursorKind::$g_variant), )+
                    _ => Err(())
                }
            }
        }

-        impl ToCss for Cursor {
+        impl ToCss for CursorKind {
            fn to_css<W>(&self, dest: &mut W) -> ::std::fmt::Result where W: ::std::fmt::Write {
                match *self {
-                    $( Cursor::$c_variant => dest.write_str($c_css), )+
-                    $( #[cfg(feature = "gecko")] Cursor::$g_variant => dest.write_str($g_css), )+
+                    $( CursorKind::$c_variant => dest.write_str($c_css), )+
+                    $( #[cfg(feature = "gecko")] CursorKind::$g_variant => dest.write_str($g_css), )+
                }
            }
        }
    }
 }

-
 define_cursor! {
    common properties = [
        "none" => None = 0,
@ -94,12 +93,13 @@ define_cursor! {
        "all-scroll" => AllScroll = 32,
        "zoom-in" => ZoomIn = 33,
        "zoom-out" => ZoomOut = 34,
+        "auto" => Auto = 35,
    ]
    // gecko only properties
    gecko properties = [
-        "-moz-grab" => MozGrab = 35,
-        "-moz-grabbing" => MozGrabbing = 36,
-        "-moz-zoom-in" => MozZoomIn = 37,
-        "-moz-zoom-out" => MozZoomOut = 38,
+        "-moz-grab" => MozGrab = 36,
+        "-moz-grabbing" => MozGrabbing = 37,
+        "-moz-zoom-in" => MozZoomIn = 38,
+        "-moz-zoom-out" => MozZoomOut = 39,
    ]
 }
--- a/ports/cef/window.rs
+++ b/ports/cef/window.rs
@ -33,7 +33,7 @@ use std::os::raw::{c_char, c_void};
 use std::ptr;
 use std::rc::Rc;
 use servo_url::ServoUrl;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 use style_traits::DevicePixel;
 #[cfg(target_os="linux")]
 extern crate x11;
@ -104,69 +104,68 @@ impl Window {
        vec![WindowEvent::Idle]
    }

-    fn cursor_type_for_cursor(&self, cursor: Cursor) -> cef_cursor_type_t {
+    fn cursor_type_for_cursor(&self, cursor: CursorKind) -> cef_cursor_type_t {
        match cursor {
-            Cursor::None => return cef_cursor_type_t::CT_NONE,
-            Cursor::ContextMenu => return cef_cursor_type_t::CT_CONTEXTMENU,
-            Cursor::Grabbing => return cef_cursor_type_t::CT_GRABBING,
-            Cursor::Crosshair => return cef_cursor_type_t::CT_CROSS,
-            Cursor::Copy => return cef_cursor_type_t::CT_COPY,
-            Cursor::Alias => return cef_cursor_type_t::CT_ALIAS,
-            Cursor::Text => return cef_cursor_type_t::CT_IBEAM,
-            Cursor::Grab | Cursor::AllScroll =>
-                return cef_cursor_type_t::CT_GRAB,
-            Cursor::NoDrop => return cef_cursor_type_t::CT_NODROP,
-            Cursor::NotAllowed => return cef_cursor_type_t::CT_NOTALLOWED,
-            Cursor::Pointer => return cef_cursor_type_t::CT_POINTER,
-            Cursor::SResize => return cef_cursor_type_t::CT_SOUTHRESIZE,
-            Cursor::WResize => return cef_cursor_type_t::CT_WESTRESIZE,
-            Cursor::EwResize => return cef_cursor_type_t::CT_EASTWESTRESIZE,
-            Cursor::ColResize => return cef_cursor_type_t::CT_COLUMNRESIZE,
-            Cursor::EResize => return cef_cursor_type_t::CT_EASTRESIZE,
-            Cursor::NResize => return cef_cursor_type_t::CT_NORTHRESIZE,
-            Cursor::NsResize => return cef_cursor_type_t::CT_NORTHSOUTHRESIZE,
-            Cursor::RowResize => return cef_cursor_type_t::CT_ROWRESIZE,
-            Cursor::VerticalText => return cef_cursor_type_t::CT_VERTICALTEXT,
-            _ => return cef_cursor_type_t::CT_POINTER,
+            CursorKind::None => cef_cursor_type_t::CT_NONE,
+            CursorKind::ContextMenu => cef_cursor_type_t::CT_CONTEXTMENU,
+            CursorKind::Grabbing => cef_cursor_type_t::CT_GRABBING,
+            CursorKind::Crosshair => cef_cursor_type_t::CT_CROSS,
+            CursorKind::Copy => cef_cursor_type_t::CT_COPY,
+            CursorKind::Alias => cef_cursor_type_t::CT_ALIAS,
+            CursorKind::Text => cef_cursor_type_t::CT_IBEAM,
+            CursorKind::Grab | CursorKind::AllScroll => cef_cursor_type_t::CT_GRAB,
+            CursorKind::NoDrop => cef_cursor_type_t::CT_NODROP,
+            CursorKind::NotAllowed => cef_cursor_type_t::CT_NOTALLOWED,
+            CursorKind::Pointer => cef_cursor_type_t::CT_POINTER,
+            CursorKind::SResize => cef_cursor_type_t::CT_SOUTHRESIZE,
+            CursorKind::WResize => cef_cursor_type_t::CT_WESTRESIZE,
+            CursorKind::EwResize => cef_cursor_type_t::CT_EASTWESTRESIZE,
+            CursorKind::ColResize => cef_cursor_type_t::CT_COLUMNRESIZE,
+            CursorKind::EResize => cef_cursor_type_t::CT_EASTRESIZE,
+            CursorKind::NResize => cef_cursor_type_t::CT_NORTHRESIZE,
+            CursorKind::NsResize => cef_cursor_type_t::CT_NORTHSOUTHRESIZE,
+            CursorKind::RowResize => cef_cursor_type_t::CT_ROWRESIZE,
+            CursorKind::VerticalText => cef_cursor_type_t::CT_VERTICALTEXT,
+            _ => cef_cursor_type_t::CT_POINTER,
        }
    }

    /// Returns the Cocoa cursor for a CSS cursor. These match Firefox, except where Firefox
    /// bundles custom resources (which we don't yet do).
    #[cfg(target_os="macos")]
-    fn cursor_handle_for_cursor(&self, cursor: Cursor) -> cef_cursor_handle_t {
+    fn cursor_handle_for_cursor(&self, cursor: CursorKind) -> cef_cursor_handle_t {
        use cocoa::base::class;

        unsafe {
            match cursor {
-                Cursor::None => return 0 as cef_cursor_handle_t,
-                Cursor::ContextMenu => msg_send![class("NSCursor"), contextualMenuCursor],
-                Cursor::Grabbing => msg_send![class("NSCursor"), closedHandCursor],
-                Cursor::Crosshair => msg_send![class("NSCursor"), crosshairCursor],
-                Cursor::Copy => msg_send![class("NSCursor"), dragCopyCursor],
-                Cursor::Alias => msg_send![class("NSCursor"), dragLinkCursor],
-                Cursor::Text => msg_send![class("NSCursor"), IBeamCursor],
-                Cursor::Grab | Cursor::AllScroll =>
+                CursorKind::None => return 0 as cef_cursor_handle_t,
+                CursorKind::ContextMenu => msg_send![class("NSCursor"), contextualMenuCursor],
+                CursorKind::Grabbing => msg_send![class("NSCursor"), closedHandCursor],
+                CursorKind::Crosshair => msg_send![class("NSCursor"), crosshairCursor],
+                CursorKind::Copy => msg_send![class("NSCursor"), dragCopyCursor],
+                CursorKind::Alias => msg_send![class("NSCursor"), dragLinkCursor],
+                CursorKind::Text => msg_send![class("NSCursor"), IBeamCursor],
+                CursorKind::Grab | CursorKind::AllScroll =>
                    msg_send![class("NSCursor"), openHandCursor],
-                Cursor::NoDrop | Cursor::NotAllowed =>
+                CursorKind::NoDrop | CursorKind::NotAllowed =>
                    msg_send![class("NSCursor"), operationNotAllowedCursor],
-                Cursor::Pointer => msg_send![class("NSCursor"), pointingHandCursor],
-                Cursor::SResize => msg_send![class("NSCursor"), resizeDownCursor],
-                Cursor::WResize => msg_send![class("NSCursor"), resizeLeftCursor],
-                Cursor::EwResize | Cursor::ColResize =>
+                CursorKind::Pointer => msg_send![class("NSCursor"), pointingHandCursor],
+                CursorKind::SResize => msg_send![class("NSCursor"), resizeDownCursor],
+                CursorKind::WResize => msg_send![class("NSCursor"), resizeLeftCursor],
+                CursorKind::EwResize | CursorKind::ColResize =>
                    msg_send![class("NSCursor"), resizeLeftRightCursor],
-                Cursor::EResize => msg_send![class("NSCursor"), resizeRightCursor],
-                Cursor::NResize => msg_send![class("NSCursor"), resizeUpCursor],
-                Cursor::NsResize | Cursor::RowResize =>
+                CursorKind::EResize => msg_send![class("NSCursor"), resizeRightCursor],
+                CursorKind::NResize => msg_send![class("NSCursor"), resizeUpCursor],
+                CursorKind::NsResize | CursorKind::RowResize =>
                    msg_send![class("NSCursor"), resizeUpDownCursor],
-                Cursor::VerticalText => msg_send![class("NSCursor"), IBeamCursorForVerticalLayout],
+                CursorKind::VerticalText => msg_send![class("NSCursor"), IBeamCursorForVerticalLayout],
                _ => msg_send![class("NSCursor"), arrowCursor],
            }
        }
    }

    #[cfg(not(target_os="macos"))]
-    fn cursor_handle_for_cursor(&self, _: Cursor) -> cef_cursor_handle_t {
+    fn cursor_handle_for_cursor(&self, _: CursorKind) -> cef_cursor_handle_t {
        0
    }

@ -488,7 +487,7 @@ impl WindowMethods for Window {
        // TODO(negge)
    }

-    fn set_cursor(&self, cursor: Cursor) {
+    fn set_cursor(&self, cursor: CursorKind) {
        use types::{CefCursorInfo,cef_point_t,cef_size_t};
        let browser = self.cef_browser.borrow();
        if let Some(ref browser) = *browser {
--- a/ports/glutin/window.rs
+++ b/ports/glutin/window.rs
@ -42,7 +42,7 @@ use std::rc::Rc;
 use std::thread;
 use std::time;
 use style_traits::DevicePixel;
-use style_traits::cursor::Cursor;
+use style_traits::cursor::CursorKind;
 #[cfg(target_os = "windows")]
 use user32;
 use webrender_api::{DeviceUintRect, DeviceUintSize, ScrollLocation};
@ -1190,47 +1190,48 @@ impl WindowMethods for Window {
    }

    /// Has no effect on Android.
-    fn set_cursor(&self, c: Cursor) {
+    fn set_cursor(&self, cursor: CursorKind) {
        match self.kind {
            WindowKind::Window(ref window) => {
                use glutin::MouseCursor;

-                let glutin_cursor = match c {
-                    Cursor::None => MouseCursor::NoneCursor,
-                    Cursor::Default => MouseCursor::Default,
-                    Cursor::Pointer => MouseCursor::Hand,
-                    Cursor::ContextMenu => MouseCursor::ContextMenu,
-                    Cursor::Help => MouseCursor::Help,
-                    Cursor::Progress => MouseCursor::Progress,
-                    Cursor::Wait => MouseCursor::Wait,
-                    Cursor::Cell => MouseCursor::Cell,
-                    Cursor::Crosshair => MouseCursor::Crosshair,
-                    Cursor::Text => MouseCursor::Text,
-                    Cursor::VerticalText => MouseCursor::VerticalText,
-                    Cursor::Alias => MouseCursor::Alias,
-                    Cursor::Copy => MouseCursor::Copy,
-                    Cursor::Move => MouseCursor::Move,
-                    Cursor::NoDrop => MouseCursor::NoDrop,
-                    Cursor::NotAllowed => MouseCursor::NotAllowed,
-                    Cursor::Grab => MouseCursor::Grab,
-                    Cursor::Grabbing => MouseCursor::Grabbing,
-                    Cursor::EResize => MouseCursor::EResize,
-                    Cursor::NResize => MouseCursor::NResize,
-                    Cursor::NeResize => MouseCursor::NeResize,
-                    Cursor::NwResize => MouseCursor::NwResize,
-                    Cursor::SResize => MouseCursor::SResize,
-                    Cursor::SeResize => MouseCursor::SeResize,
-                    Cursor::SwResize => MouseCursor::SwResize,
-                    Cursor::WResize => MouseCursor::WResize,
-                    Cursor::EwResize => MouseCursor::EwResize,
-                    Cursor::NsResize => MouseCursor::NsResize,
-                    Cursor::NeswResize => MouseCursor::NeswResize,
-                    Cursor::NwseResize => MouseCursor::NwseResize,
-                    Cursor::ColResize => MouseCursor::ColResize,
-                    Cursor::RowResize => MouseCursor::RowResize,
-                    Cursor::AllScroll => MouseCursor::AllScroll,
-                    Cursor::ZoomIn => MouseCursor::ZoomIn,
-                    Cursor::ZoomOut => MouseCursor::ZoomOut,
+                let glutin_cursor = match cursor {
+                    CursorKind::Auto => MouseCursor::Default,
+                    CursorKind::None => MouseCursor::NoneCursor,
+                    CursorKind::Default => MouseCursor::Default,
+                    CursorKind::Pointer => MouseCursor::Hand,
+                    CursorKind::ContextMenu => MouseCursor::ContextMenu,
+                    CursorKind::Help => MouseCursor::Help,
+                    CursorKind::Progress => MouseCursor::Progress,
+                    CursorKind::Wait => MouseCursor::Wait,
+                    CursorKind::Cell => MouseCursor::Cell,
+                    CursorKind::Crosshair => MouseCursor::Crosshair,
+                    CursorKind::Text => MouseCursor::Text,
+                    CursorKind::VerticalText => MouseCursor::VerticalText,
+                    CursorKind::Alias => MouseCursor::Alias,
+                    CursorKind::Copy => MouseCursor::Copy,
+                    CursorKind::Move => MouseCursor::Move,
+                    CursorKind::NoDrop => MouseCursor::NoDrop,
+                    CursorKind::NotAllowed => MouseCursor::NotAllowed,
+                    CursorKind::Grab => MouseCursor::Grab,
+                    CursorKind::Grabbing => MouseCursor::Grabbing,
+                    CursorKind::EResize => MouseCursor::EResize,
+                    CursorKind::NResize => MouseCursor::NResize,
+                    CursorKind::NeResize => MouseCursor::NeResize,
+                    CursorKind::NwResize => MouseCursor::NwResize,
+                    CursorKind::SResize => MouseCursor::SResize,
+                    CursorKind::SeResize => MouseCursor::SeResize,
+                    CursorKind::SwResize => MouseCursor::SwResize,
+                    CursorKind::WResize => MouseCursor::WResize,
+                    CursorKind::EwResize => MouseCursor::EwResize,
+                    CursorKind::NsResize => MouseCursor::NsResize,
+                    CursorKind::NeswResize => MouseCursor::NeswResize,
+                    CursorKind::NwseResize => MouseCursor::NwseResize,
+                    CursorKind::ColResize => MouseCursor::ColResize,
+                    CursorKind::RowResize => MouseCursor::RowResize,
+                    CursorKind::AllScroll => MouseCursor::AllScroll,
+                    CursorKind::ZoomIn => MouseCursor::ZoomIn,
+                    CursorKind::ZoomOut => MouseCursor::ZoomOut,
                };
                window.set_cursor(glutin_cursor);
            }