Struct DrawContext 

pub struct DrawContext { /* private fields */ }

Context returned by DrawHandler that stores a Context along with additional data required for drawing.

Methods from Deref<Target = Context>

pub fn to_raw_none(&self) -> *mut cairo_t

pub fn status(&self) -> Result<(), Error>

pub fn save(&self) -> Result<(), Error>

pub fn restore(&self) -> Result<(), Error>

pub fn target(&self) -> Surface

pub fn push_group(&self)

pub fn push_group_with_content(&self, content: Content)

pub fn pop_group(&self) -> Result<Pattern, Error>

pub fn pop_group_to_source(&self) -> Result<(), Error>

pub fn group_target(&self) -> Surface

pub fn set_source_rgb(&self, red: f64, green: f64, blue: f64)

Examples found in repository

relm4/examples/drawing.rs (line 189)

fn draw(cx: &Context, points: &[Point]) {
    for point in points {
        let Point {
            x,
            y,
            color: Color { r, g, b },
            ..
        } = *point;
        cx.set_source_rgb(r, g, b);
        cx.arc(x, y, 10.0, 0.0, std::f64::consts::PI * 2.0);
        cx.fill().expect("Couldn't fill arc");
    }
}

pub fn set_source_rgba(&self, red: f64, green: f64, blue: f64, alpha: f64)

Examples found in repository

relm4/examples/drawing.rs (line 82)

    fn update(&mut self, msg: Msg, _sender: ComponentSender<Self>, _root: &Self::Root) {
        let cx = self.handler.get_context();

        match msg {
            Msg::AddPoint((x, y)) => {
                self.points.push(Point::new(x, y));
            }
            Msg::Resize => {
                self.width = self.handler.width() as f64;
                self.height = self.handler.height() as f64;
            }
            Msg::Reset => {
                cx.set_operator(Operator::Clear);
                cx.set_source_rgba(0.0, 0.0, 0.0, 0.0);
                cx.paint().expect("Couldn't fill context");
            }
        }

        draw(&cx, &self.points);
    }

pub fn set_source(&self, source: impl AsRef<Pattern>) -> Result<(), Error>

pub fn source(&self) -> Pattern

pub fn set_source_surface( &self, surface: impl AsRef<Surface>, x: f64, y: f64, ) -> Result<(), Error>

pub fn set_antialias(&self, antialias: Antialias)

pub fn antialias(&self) -> Antialias

pub fn set_dash(&self, dashes: &[f64], offset: f64)

pub fn dash_count(&self) -> i32

pub fn dash(&self) -> (Vec<f64>, f64)

pub fn dash_dashes(&self) -> Vec<f64>

pub fn dash_offset(&self) -> f64

pub fn set_fill_rule(&self, fill_rule: FillRule)

pub fn fill_rule(&self) -> FillRule

pub fn set_line_cap(&self, arg: LineCap)

pub fn line_cap(&self) -> LineCap

pub fn set_line_join(&self, arg: LineJoin)

pub fn line_join(&self) -> LineJoin

pub fn set_line_width(&self, arg: f64)

pub fn line_width(&self) -> f64

pub fn set_miter_limit(&self, arg: f64)

pub fn miter_limit(&self) -> f64

pub fn set_operator(&self, op: Operator)

Examples found in repository

relm4/examples/drawing.rs (line 81)

    fn update(&mut self, msg: Msg, _sender: ComponentSender<Self>, _root: &Self::Root) {
        let cx = self.handler.get_context();

        match msg {
            Msg::AddPoint((x, y)) => {
                self.points.push(Point::new(x, y));
            }
            Msg::Resize => {
                self.width = self.handler.width() as f64;
                self.height = self.handler.height() as f64;
            }
            Msg::Reset => {
                cx.set_operator(Operator::Clear);
                cx.set_source_rgba(0.0, 0.0, 0.0, 0.0);
                cx.paint().expect("Couldn't fill context");
            }
        }

        draw(&cx, &self.points);
    }

pub fn operator(&self) -> Operator

pub fn set_tolerance(&self, arg: f64)

pub fn tolerance(&self) -> f64

pub fn clip(&self)

pub fn clip_preserve(&self)

pub fn clip_extents(&self) -> Result<(f64, f64, f64, f64), Error>

pub fn in_clip(&self, x: f64, y: f64) -> Result<bool, Error>

pub fn reset_clip(&self)

pub fn copy_clip_rectangle_list(&self) -> Result<RectangleList, Error>

pub fn fill(&self) -> Result<(), Error>

Examples found in repository

relm4/examples/drawing.rs (line 191)

fn draw(cx: &Context, points: &[Point]) {
    for point in points {
        let Point {
            x,
            y,
            color: Color { r, g, b },
            ..
        } = *point;
        cx.set_source_rgb(r, g, b);
        cx.arc(x, y, 10.0, 0.0, std::f64::consts::PI * 2.0);
        cx.fill().expect("Couldn't fill arc");
    }
}

pub fn fill_preserve(&self) -> Result<(), Error>

pub fn fill_extents(&self) -> Result<(f64, f64, f64, f64), Error>

pub fn in_fill(&self, x: f64, y: f64) -> Result<bool, Error>

pub fn mask(&self, pattern: impl AsRef<Pattern>) -> Result<(), Error>

pub fn mask_surface( &self, surface: impl AsRef<Surface>, x: f64, y: f64, ) -> Result<(), Error>

pub fn paint(&self) -> Result<(), Error>

Examples found in repository

relm4/examples/drawing.rs (line 83)

    fn update(&mut self, msg: Msg, _sender: ComponentSender<Self>, _root: &Self::Root) {
        let cx = self.handler.get_context();

        match msg {
            Msg::AddPoint((x, y)) => {
                self.points.push(Point::new(x, y));
            }
            Msg::Resize => {
                self.width = self.handler.width() as f64;
                self.height = self.handler.height() as f64;
            }
            Msg::Reset => {
                cx.set_operator(Operator::Clear);
                cx.set_source_rgba(0.0, 0.0, 0.0, 0.0);
                cx.paint().expect("Couldn't fill context");
            }
        }

        draw(&cx, &self.points);
    }

pub fn paint_with_alpha(&self, alpha: f64) -> Result<(), Error>

pub fn stroke(&self) -> Result<(), Error>

pub fn stroke_preserve(&self) -> Result<(), Error>

pub fn stroke_extents(&self) -> Result<(f64, f64, f64, f64), Error>

pub fn in_stroke(&self, x: f64, y: f64) -> Result<bool, Error>

pub fn copy_page(&self) -> Result<(), Error>

pub fn show_page(&self) -> Result<(), Error>

pub fn reference_count(&self) -> u32

pub fn translate(&self, tx: f64, ty: f64)

pub fn scale(&self, sx: f64, sy: f64)

pub fn rotate(&self, angle: f64)

pub fn transform(&self, matrix: Matrix)

pub fn set_matrix(&self, matrix: Matrix)

pub fn matrix(&self) -> Matrix

pub fn identity_matrix(&self)

pub fn user_to_device(&self, x: f64, y: f64) -> (f64, f64)

pub fn user_to_device_distance( &self, dx: f64, dy: f64, ) -> Result<(f64, f64), Error>

pub fn device_to_user(&self, x: f64, y: f64) -> Result<(f64, f64), Error>

pub fn device_to_user_distance( &self, dx: f64, dy: f64, ) -> Result<(f64, f64), Error>

pub fn select_font_face( &self, family: &str, slant: FontSlant, weight: FontWeight, )

pub fn set_font_size(&self, size: f64)

pub fn set_font_matrix(&self, matrix: Matrix)

pub fn font_matrix(&self) -> Matrix

pub fn set_font_options(&self, options: &FontOptions)

pub fn font_options(&self) -> Result<FontOptions, Error>

pub fn set_font_face(&self, font_face: &FontFace)

pub fn font_face(&self) -> FontFace

pub fn set_scaled_font(&self, scaled_font: &ScaledFont)

pub fn scaled_font(&self) -> ScaledFont

pub fn show_text(&self, text: &str) -> Result<(), Error>

pub fn show_glyphs(&self, glyphs: &[Glyph]) -> Result<(), Error>

pub fn show_text_glyphs( &self, text: &str, glyphs: &[Glyph], clusters: &[TextCluster], cluster_flags: TextClusterFlags, ) -> Result<(), Error>

pub fn font_extents(&self) -> Result<FontExtents, Error>

pub fn text_extents(&self, text: &str) -> Result<TextExtents, Error>

pub fn glyph_extents(&self, glyphs: &[Glyph]) -> Result<TextExtents, Error>

pub fn copy_path(&self) -> Result<Path, Error>

pub fn copy_path_flat(&self) -> Result<Path, Error>

pub fn append_path(&self, path: &Path)

pub fn has_current_point(&self) -> Result<bool, Error>

pub fn current_point(&self) -> Result<(f64, f64), Error>

pub fn new_path(&self)

pub fn new_sub_path(&self)

pub fn close_path(&self)

pub fn arc(&self, xc: f64, yc: f64, radius: f64, angle1: f64, angle2: f64)

Examples found in repository

relm4/examples/drawing.rs (line 190)

fn draw(cx: &Context, points: &[Point]) {
    for point in points {
        let Point {
            x,
            y,
            color: Color { r, g, b },
            ..
        } = *point;
        cx.set_source_rgb(r, g, b);
        cx.arc(x, y, 10.0, 0.0, std::f64::consts::PI * 2.0);
        cx.fill().expect("Couldn't fill arc");
    }
}

pub fn arc_negative( &self, xc: f64, yc: f64, radius: f64, angle1: f64, angle2: f64, )

pub fn curve_to(&self, x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64)

pub fn line_to(&self, x: f64, y: f64)

pub fn move_to(&self, x: f64, y: f64)

pub fn rectangle(&self, x: f64, y: f64, width: f64, height: f64)

pub fn text_path(&self, str_: &str)

pub fn glyph_path(&self, glyphs: &[Glyph])

pub fn rel_curve_to( &self, dx1: f64, dy1: f64, dx2: f64, dy2: f64, dx3: f64, dy3: f64, )

pub fn rel_line_to(&self, dx: f64, dy: f64)

pub fn rel_move_to(&self, dx: f64, dy: f64)

pub fn path_extents(&self) -> Result<(f64, f64, f64, f64), Error>

pub fn tag_begin(&self, tag_name: &str, attributes: &str)

Available on crate feature v1_16 only.

pub fn tag_end(&self, tag_name: &str)

Available on crate feature v1_16 only.

Trait Implementations

impl Debug for DrawContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for DrawContext

type Target = Context

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for DrawContext

fn drop(&mut self)

Executes the destructor for this type.