fn new(values: &ComputedValues, x: Option<f64>, y: Option<f64>) -> Chunk {

        Chunk {

            values: Rc::new(values.clone()),

            spans: Vec::new(),

    }

    fn from_chunk(layout_context: &LayoutContext, chunk: &Chunk) -> MeasuredChunk {

        let mut measured_spans: Vec<MeasuredSpan> = chunk

            .filter_map(|span| MeasuredSpan::from_span(layout_context, span))

        let (chunk_dx, chunk_dy) = if let Some(first) = measured_spans.first_mut() {

            let dx = first.dx;

            let dy = first.dy;

            first.dx = 0.0;

            first.dy = 0.0;

            (dx, dy)

            (0.0, 0.0)

        MeasuredChunk {

            values: chunk.values.clone(),

            x: chunk.x,

            y: chunk.y,

            spans: measured_spans,

    }

    fn from_measured(

        let chunk_direction = measured.values.direction();

        let mut positioned = Vec::new();

        let mut x = 0.0;

        let mut y = 0.0;

        let mut chunk_bounds: Option<Rect> = None;

        for mspan in &measured.spans {

            let params = NormalizeParams::new(&mspan.values, &layout_context.viewport);

            let layout = mspan.layout.clone();

            let layout_size = mspan.layout_size;

            let values = mspan.values.clone();

            let dx = mspan.dx;

            let dy = mspan.dy;

            let advance = mspan.advance;

            let baseline_offset = compute_baseline_offset(&layout, &values, &params);

            let start_pos = match chunk_direction {

                Direction::Ltr => (x, y),

                Direction::Rtl => (x - advance.0, y),

            let span_advance = match chunk_direction {

                Direction::Ltr => (advance.0, advance.1),

                Direction::Rtl => (-advance.0, advance.1),

            let rendered_position = if layout_context.writing_mode.is_horizontal() {

                (start_pos.0 + dx, start_pos.1 - baseline_offset + dy)

                Rect::from_size(layout_size.0, layout_size.1).translate(rendered_position);

            if let Some(bounds) = chunk_bounds {

                chunk_bounds = Some(bounds.union(&span_bounds));

                chunk_bounds = Some(span_bounds);

            x = x + span_advance.0 + dx;

            y = y + span_advance.1 + dy;

            let positioned_span = PositionedSpan {

                layout,

                values,

                rendered_position,

                next_span_position: (x, y),

                link_target: mspan.link_target.clone(),

            positioned.push(positioned_span);

        }

        let anchor_offset = text_anchor_offset(

            measured.values.text_anchor(),

            layout_context.writing_mode,

            chunk_bounds.unwrap_or_default(),

        let mut next_chunk_x = chunk_x;

        let mut next_chunk_y = chunk_y;

        for pspan in &mut positioned {

            pspan.rendered_position.0 += chunk_x + anchor_offset.0 + measured.dx;

            pspan.rendered_position.1 += chunk_y + anchor_offset.1 + measured.dy;

            next_chunk_x = chunk_x + pspan.next_span_position.0 + anchor_offset.0 + measured.dx;

            next_chunk_y = chunk_y + pspan.next_span_position.1 + anchor_offset.1 + measured.dy;

        PositionedChunk {

            next_chunk_x,

            next_chunk_y,

            spans: positioned,

    }

fn compute_baseline_offset(

    let baseline = f64::from(layout.baseline()) / f64::from(pango::SCALE);

    let baseline_shift = values.baseline_shift().0.to_user(params);

    baseline + baseline_shift

}

fn text_anchor_offset(

    let (w, h) = (chunk_bounds.width(), chunk_bounds.height());

    let x0 = chunk_bounds.x0;

    if writing_mode.is_horizontal() {

        match (anchor, direction) {

            (TextAnchor::Start,  Direction::Ltr) => (-x0, 0.0),

            (TextAnchor::Start,  Direction::Rtl) => (-x0 - w, 0.0),

            (TextAnchor::Middle, Direction::Ltr) => (-x0 - w / 2.0, 0.0),

            (TextAnchor::Middle, Direction::Rtl) => (-x0 - w / 2.0, 0.0),

            (TextAnchor::End,    Direction::Ltr) => (-x0 - w, 0.0),

            (TextAnchor::End,    Direction::Rtl) => (-x0, 0.0),

        match anchor {

            TextAnchor::Start => (0.0, 0.0),

            TextAnchor::Middle => (0.0, -h / 2.0),

            TextAnchor::End => (0.0, -h),

}

    fn new(

        Span {

            values,

            text: text.to_string(),

            link_target,

    }

struct PangoUnits(i32);

    fn from_pixels(v: f64) -> Option<Self> {

        cast::i32(v * f64::from(pango::SCALE) + 0.5)

    }

    fn from_span(layout_context: &LayoutContext, span: &Span) -> Option<MeasuredSpan> {

        let values = span.values.clone();

        let params = NormalizeParams::new(&values, &layout_context.viewport);

        let properties = FontProperties::new(&values, &params);

        let bidi_control = BidiControl::from_unicode_bidi_and_direction(

            properties.unicode_bidi,

            properties.direction,

        let with_control_chars = wrap_with_direction_control_chars(&span.text, &bidi_control);

        if let Some(layout) = create_pango_layout(layout_context, &properties, &with_control_chars)

            let (w, h) = layout.size();

            let w = f64::from(w) / f64::from(pango::SCALE);

            let h = f64::from(h) / f64::from(pango::SCALE);

            let advance = if layout_context.writing_mode.is_horizontal() {

                (w, 0.0)

            Some(MeasuredSpan {

                values,

                layout,

                layout_size: (w, h),

                advance,

                dx: span.dx,

                dy: span.dy,

                link_target: span.link_target.clone(),

        } else {

            None

    }

fn gravity_is_vertical(gravity: pango::Gravity) -> bool {

    matches!(gravity, pango::Gravity::East | pango::Gravity::West)

}

fn compute_text_box(

    let (ink, _) = layout.extents();

    if ink.width() == 0 || ink.height() == 0 {

        return None;

    let ink_x = f64::from(ink.x());

    let ink_y = f64::from(ink.y());

    let ink_width = f64::from(ink.width());

    let ink_height = f64::from(ink.height());

    let pango_scale = f64::from(pango::SCALE);

    let (x, y, w, h) = if gravity_is_vertical(gravity) {

        (

            x + ink_x / pango_scale,

            y + ink_y / pango_scale,

            ink_width / pango_scale,

            ink_height / pango_scale,

    let r = Rect::new(x, y, x + w, y + h);

    let bbox = BoundingBox::new()

    Some(bbox)

}

    fn layout(

        let params = NormalizeParams::new(&self.values, &layout_context.viewport);

        let layout = self.layout.clone();

        let is_visible = self.values.is_visible();

        let (x, y) = self.rendered_position;

        let stroke = Stroke::new(&self.values, &params);

        let gravity = layout.context().gravity();

        let bbox = compute_text_box(&layout, x, y, *layout_context.transform, gravity);

        let stroke_paint = self.values.stroke().0.resolve(

            self.values.stroke_opacity().0,

            self.values.color().0,

            None,

            None,

            &layout_context.session,

        );

        let fill_paint = self.values.fill().0.resolve(

            self.values.fill_opacity().0,

            self.values.color().0,

            None,

            None,

            &layout_context.session,

        );

        let paint_order = self.values.paint_order();

        let text_rendering = self.values.text_rendering();

        LayoutSpan {

            layout,

            stroke,

            stroke_paint,

            fill_paint,

            values: self.values.clone(),

            link_target: self.link_target.clone(),

    }

fn children_to_chunks(

    let mut dx = dx;

    let mut dy = dy;

    for child in node.children() {

        if child.is_chars() {

            let values = cascaded.get();

            child.borrow_chars().to_chunks(

                Rc::new(values.clone()),

                chunks,

                dx,

                dy,

                link.clone(),

            );

            assert!(child.is_element());

            match *child.borrow_element_data() {

                ElementData::TSpan(ref tspan) => {

                    let cascaded = CascadedValues::clone_with_node(cascaded, &child);

                    tspan.to_chunks(

                        dx,

                        dy,

                        depth + 1,

                        link.clone(),

                }

                ElementData::Link(ref link) => {

                    let tspan = TSpan::default();

                    let cascaded = CascadedValues::clone_with_node(cascaded, &child);

                    tspan.to_chunks(

                        dx,

                        dy,

                        depth + 1,

                        link.link.clone(),

                }

                ElementData::TRef(ref tref) => {

                    let cascaded = CascadedValues::clone_with_node(cascaded, &child);

                    tref.to_chunks(

                        depth + 1,

                }

        }

        dx = 0.0;

        dy = 0.0;

    }

}

#[derive(Default)]

    string: RefCell<String>,

    space_normalized: RefCell<Option<String>>,

    pub fn new(initial_text: &str) -> Chars {

        Chars {

            string: RefCell::new(String::from(initial_text)),

            space_normalized: RefCell::new(None),

    }

    pub fn is_empty(&self) -> bool {

        self.string.borrow().is_empty()

    }

    pub fn append(&self, s: &str) {

        self.string.borrow_mut().push_str(s);

        *self.space_normalized.borrow_mut() = None;

    }

    fn ensure_normalized_string(&self, node: &Node, values: &ComputedValues) {

        let mut normalized = self.space_normalized.borrow_mut();

        if (*normalized).is_none() {

            let mode = match values.xml_space() {

                XmlSpace::Default => XmlSpaceNormalize::Default(NormalizeDefault {

                    has_element_before: node.previous_sibling().is_some(),

                    has_element_after: node.next_sibling().is_some(),

                }),

                XmlSpace::Preserve => XmlSpaceNormalize::Preserve,

            *normalized = Some(xml_space_normalize(mode, &self.string.borrow()));

    }

    fn make_span(

        self.ensure_normalized_string(node, &values);

        Span::new(

            self.space_normalized.borrow().as_ref().unwrap(),

            values,

            link_target,

    }

    fn to_chunks(

        let span = self.make_span(node, values, dx, dy, depth, link_target);

        let num_chunks = chunks.len();

        assert!(num_chunks > 0);

        chunks[num_chunks - 1].spans.push(span);

    }

    pub fn get_string(&self) -> String {

        self.string.borrow().clone()

    }

#[derive(Default)]

    x: Length<Horizontal>,

    y: Length<Vertical>,

    dx: Length<Horizontal>,

    dy: Length<Vertical>,

    fn make_chunks(

        let mut chunks = Vec::new();

        let values = cascaded.get();

        let params = NormalizeParams::new(values, &layout_context.viewport);

        chunks.push(Chunk::new(values, Some(x), Some(y)));

        let dx = self.dx.to_user(&params);

        let dy = self.dy.to_user(&params);

        children_to_chunks(

            None,

        chunks

    }

    fn set_attributes(&mut self, attrs: &Attributes, session: &Session) {

        for (attr, value) in attrs.iter() {

            match attr.expanded() {

                expanded_name!("", "x") => set_attribute(&mut self.x, attr.parse(value), session),

                expanded_name!("", "y") => set_attribute(&mut self.y, attr.parse(value), session),

                expanded_name!("", "dx") => set_attribute(&mut self.dx, attr.parse(value), session),

                expanded_name!("", "dy") => set_attribute(&mut self.dy, attr.parse(value), session),

        }

    }

    fn draw(

        let values = cascaded.get();

        let params = NormalizeParams::new(values, viewport);

        let elt = node.borrow_element();

        let stacking_ctx = StackingContext::new(

            draw_ctx.session(),

            &elt,

            values.transform(),

            None,

        );

            let transform = draw_ctx.get_transform_for_stacking_ctx(&stacking_ctx, clipping)?;

            let layout_context = LayoutContext {

                writing_mode: values.writing_mode(),

                transform,

                font_options: draw_ctx.get_font_options(),

                viewport: viewport.clone(),

                session: draw_ctx.session().clone(),

            let mut x = self.x.to_user(&params);

            let mut y = self.y.to_user(&params);

            let chunks = self.make_chunks(node, acquired_nodes, cascaded, &layout_context, x, y);

            let mut measured_chunks = Vec::new();

            for chunk in &chunks {

                measured_chunks.push(MeasuredChunk::from_chunk(&layout_context, chunk));

            let mut positioned_chunks = Vec::new();

            for chunk in &measured_chunks {

                let chunk_x = chunk.x.unwrap_or(x);

                let chunk_y = chunk.y.unwrap_or(y);

                    PositionedChunk::from_measured(&layout_context, chunk, chunk_x, chunk_y);

                x = positioned.next_chunk_x;

                y = positioned.next_chunk_y;

                positioned_chunks.push(positioned);

            let mut layout_spans = Vec::new();

            for chunk in &positioned_chunks {

                for span in &chunk.spans {

                    layout_spans.push(span.layout(&layout_context, acquired_nodes));

            let empty_bbox = BoundingBox::new().with_transform(*transform);

            let text_bbox = layout_spans.iter().fold(empty_bbox, |mut bbox, span| {

                if let Some(ref span_bbox) = span.bbox {

                    bbox.insert(span_bbox);

                bbox

            });

            let mut text_spans = Vec::new();

            for span in layout_spans {

                let normalize_values = NormalizeValues::new(&span.values);

                let stroke_paint = span.stroke_paint.to_user_space(

                    &layout_context.viewport,

                );

                let fill_paint = span.fill_paint.to_user_space(

                    &layout_context.viewport,

                let text_span = TextSpan {

                    layout: span.layout,

                    gravity: span.gravity,

                    bbox: span.bbox,

                    is_visible: span.is_visible,

                    x: span.x,

                    y: span.y,

                    paint_order: span.paint_order,

                    stroke: span.stroke,

                    stroke_paint,

                    text_rendering: span.text_rendering,

                    link_target: span.link_target,

                text_spans.push(text_span);

            }

            layout::Text { spans: text_spans }

        };

        let layer = Layer {

            kind: LayerKind::Text(Box::new(layout_text)),

            stacking_ctx,

        draw_ctx.draw_layer(&layer, acquired_nodes, clipping, viewport)

    }

#[derive(Default)]

    link: Option<NodeId>,

    fn to_chunks(

        if self.link.is_none() {

        let link = self.link.as_ref().unwrap();

        let values = cascaded.get();

        if !values.is_displayed() {

        if let Ok(acquired) = acquired_nodes.acquire(link) {

            let c = acquired.get();

            extract_chars_children_to_chunks_recursively(chunks, c, Rc::new(values.clone()), depth);

        } else {

    }

fn extract_chars_children_to_chunks_recursively(

    for child in node.children() {

        let values = values.clone();

        if child.is_chars() {

            child

                .to_chunks(&child, values, chunks, 0.0, 0.0, depth, None)

        } else {

            extract_chars_children_to_chunks_recursively(chunks, &child, values, depth + 1)

    }

}

    fn set_attributes(&mut self, attrs: &Attributes, _session: &Session) {

        self.link = attrs

            .find(|(attr, _)| attr.expanded() == expanded_name!(xlink "href"))

            .and_then(|(attr, value)| NodeId::parse(value).attribute(attr).ok());

    }

#[derive(Default)]

    x: Option<Length<Horizontal>>,

    y: Option<Length<Vertical>>,

    dx: Length<Horizontal>,

    dy: Length<Vertical>,

    fn to_chunks(

        let values = cascaded.get();

        if !values.is_displayed() {

        let params = NormalizeParams::new(values, &layout_context.viewport);

        let x = self.x.map(|l| l.to_user(&params));

        let y = self.y.map(|l| l.to_user(&params));

        let span_dx = dx + self.dx.to_user(&params);

        let span_dy = dy + self.dy.to_user(&params);

        if x.is_some() || y.is_some() {

            chunks.push(Chunk::new(values, x, y));

        children_to_chunks(

            link,

    }

    fn set_attributes(&mut self, attrs: &Attributes, session: &Session) {

        for (attr, value) in attrs.iter() {

            match attr.expanded() {

                expanded_name!("", "x") => set_attribute(&mut self.x, attr.parse(value), session),

                expanded_name!("", "y") => set_attribute(&mut self.y, attr.parse(value), session),

                expanded_name!("", "dx") => set_attribute(&mut self.dx, attr.parse(value), session),

                expanded_name!("", "dy") => set_attribute(&mut self.dy, attr.parse(value), session),

        }

    }

    fn from(s: FontStyle) -> pango::Style {

        match s {

            FontStyle::Normal => pango::Style::Normal,

            FontStyle::Italic => pango::Style::Italic,

    }

    fn from(v: FontVariant) -> pango::Variant {

        match v {

            FontVariant::Normal => pango::Variant::Normal,

            FontVariant::SmallCaps => pango::Variant::SmallCaps,

    }

    fn from(s: FontStretch) -> pango::Stretch {

        match s {

            FontStretch::Normal => pango::Stretch::Normal,

    }

    fn from(w: FontWeight) -> pango::Weight {

        pango::Weight::__Unknown(w.numeric_weight().into())

    }

    fn from(d: Direction) -> pango::Direction {

        match d {

            Direction::Rtl => pango::Direction::Rtl,

    }

    fn from(m: WritingMode) -> pango::Direction {

        match m {

            HorizontalTb | VerticalRl | VerticalLr | LrTb | Lr | Tb | TbRl => pango::Direction::Ltr,

    }

    fn from(m: WritingMode) -> pango::Gravity {

        match m {

            HorizontalTb | LrTb | Lr | RlTb | Rl => pango::Gravity::South,

    }

    fn from_unicode_bidi_and_direction(unicode_bidi: UnicodeBidi, direction: Direction) -> BidiControl {

        let (start, end) = match (unicode_bidi, direction) {

            (Normal,          _)   => (&[][..],         &[][..]),

            (BidiOverride,    Rtl) => (&[RLO][..],      &[PDF][..]),

        BidiControl { start, end }

    }

fn wrap_with_direction_control_chars(s: &str, bidi_control: &BidiControl) -> String {

        String::with_capacity(s.len() + bidi_control.start.len() + bidi_control.end.len());

    for &ch in bidi_control.start {

        res.push(ch);

    res.push_str(s);

    for &ch in bidi_control.end {

        res.push(ch);

    res

}

fn create_pango_layout(

    let pango_context =

        create_pango_context(&layout_context.font_options, &layout_context.transform);

    if let XmlLang(Some(ref lang)) = props.xml_lang {

        pango_context.set_language(Some(&pango::Language::from_string(lang.as_str())));

    pango_context.set_base_gravity(pango::Gravity::from(layout_context.writing_mode));

    match (props.unicode_bidi, props.direction) {

            pango_context.set_base_dir(pango::Direction::from(props.direction));

        (_, direction) if direction != Direction::Ltr => {

            pango_context.set_base_dir(pango::Direction::from(direction));

            pango_context.set_base_dir(pango::Direction::from(layout_context.writing_mode));

    let layout = pango::Layout::new(&pango_context);

    let font_size = PangoUnits::from_pixels(props.font_size);

    let letter_spacing = PangoUnits::from_pixels(props.letter_spacing);

    if font_size.is_none() {

        rsvg_log!(

            &layout_context.session,

    if letter_spacing.is_none() {

        rsvg_log!(

            &layout_context.session,

    if let (Some(font_size), Some(letter_spacing)) = (font_size, letter_spacing) {

        let attr_list = pango::AttrList::new();

        add_pango_attributes(&attr_list, props, 0, text.len(), font_size, letter_spacing);

        layout.set_attributes(Some(&attr_list));

        layout.set_text(text);

        layout.set_auto_dir(false);

        Some(layout)

    } else {

        None

}

fn add_pango_attributes(

    let start_index = u32::try_from(start_index).expect("Pango attribute index must fit in u32");

    let end_index = u32::try_from(end_index).expect("Pango attribute index must fit in u32");

    assert!(start_index <= end_index);

    let mut attributes = Vec::new();

    let mut font_desc = pango::FontDescription::new();

    font_desc.set_family(props.font_family.as_str());

    font_desc.set_style(pango::Style::from(props.font_style));

    font_desc.set_variant(pango::Variant::from(props.font_variant));

    font_desc.set_weight(pango::Weight::from(props.font_weight));

    font_desc.set_stretch(pango::Stretch::from(props.font_stretch));

    font_desc.set_size(font_size.0);

    attributes.push(pango::AttrFontDesc::new(&font_desc).upcast());

    attributes.push(pango::AttrInt::new_letter_spacing(letter_spacing.0).upcast());

    if props.text_decoration.overline {

    if props.text_decoration.underline {

        attributes.push(pango::AttrInt::new_underline(pango::Underline::Single).upcast());

    if props.text_decoration.strike {

        attributes.push(pango::AttrInt::new_strikethrough(true).upcast());

    for attr in &mut attributes {

        attr.set_start_index(start_index);

        attr.set_end_index(end_index);

    for attr in attributes {

        attr_list.insert(attr);

}

    fn chars_default() {

        let c = Chars::default();

        assert!(c.is_empty());

        assert!(c.space_normalized.borrow().is_none());

    }