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

        Chunk {

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

            x,

            y,

            spans: Vec::new(),

        }

    }

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

        let mut measured_spans: Vec<MeasuredSpan> = chunk

            .spans

            .iter()

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

            .collect();

        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,

            dx: chunk_dx,

            dy: chunk_dy,

            spans: measured_spans,

        }

    }

    fn from_measured(

        layout_context: &LayoutContext,

        measured: &MeasuredChunk,

        chunk_x: f64,

        chunk_y: f64,

    ) -> PositionedChunk {

        let chunk_direction = measured.values.direction();

        // Position the spans relatively to each other, starting at (0, 0)

        let mut positioned = Vec::new();

        // Start position of each span; gets advanced as each span is laid out.

        // This is the text's start position, not the bounding box.

        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)

            let span_bounds =

                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));

            } else {

                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(),

            chunk_direction,

            layout_context.writing_mode,

            chunk_bounds.unwrap_or_default(),

        );

        // Apply the text-anchor offset to each individually-positioned span, and compute the

        // start position of the next chunk.  Also add in the chunk's dx/dy.

        let mut next_chunk_x = chunk_x;

        let mut next_chunk_y = chunk_y;

        for pspan in &mut positioned {

            // Add the chunk's position, plus the text-anchor offset, plus the chunk's dx/dy.

            // This last term is a hack until librsvg adds support for multiple dx/dy values per text/tspan;

            // see the corresponding part in MeasuredChunk::from_chunk().

            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(

    layout: &pango::Layout,

    values: &ComputedValues,

    params: &NormalizeParams,

) -> f64 {

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

    let dominant_baseline = values.dominant_baseline();

    let mut layout_iter = layout.iter();

        let run = layout_iter.run_readonly();

        if run.is_some() {

            let item = run.unwrap().item();

            unsafe {

                let analysis = (*item.as_ptr()).analysis;

                if analysis.font.is_null() {

                }

            }

            let font = item.analysis().font();

            let metrics = font.metrics(None);

            let ascent = metrics.ascent();

            let descent = metrics.descent();

            let height = metrics.height();

            match dominant_baseline {

                DominantBaseline::Hanging => {

                    baseline -= f64::from(ascent - descent) / f64::from(pango::SCALE);

                }

                DominantBaseline::Middle => {

                    // Approximate meanline using strikethrough position and thickness

                    // https://mail.gnome.org/archives/gtk-i18n-list/2012-December/msg00046.html

                    baseline -= f64::from(

                        metrics.strikethrough_position() + metrics.strikethrough_thickness() / 2,

                    ) / f64::from(pango::SCALE);

                }

                DominantBaseline::Central => {

                    baseline = 0.5 * f64::from(ascent + descent) / f64::from(pango::SCALE);

                }

                DominantBaseline::TextBeforeEdge | DominantBaseline::TextTop => {

                    //baseline -= f64::from(ascent) / f64::from(pango::SCALE);

                    // Bit of a klutch, but leads to better results

                    baseline -= f64::from(2 * ascent - height) / f64::from(pango::SCALE);

                }

                DominantBaseline::TextAfterEdge | DominantBaseline::TextBottom => {

                    baseline += f64::from(descent) / f64::from(pango::SCALE);

                }

                _ => (),

            break;

        }

        if !layout_iter.next_run() {

            break;

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

    baseline + baseline_shift

}

fn text_anchor_offset(

    anchor: TextAnchor,

    direction: Direction,

    writing_mode: WritingMode,

    chunk_bounds: Rect,

) -> (f64, f64) {

    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(

        text: &str,

        values: Rc<ComputedValues>,

        dx: f64,

        dy: f64,

        depth: usize,

        link_target: Option<String>,

    ) -> Span {

        Span {

            values,

            text: text.to_string(),

            dx,

            dy,

            _depth: depth,

            link_target,

        }

    }

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

        // We want (v * f64::from(pango::SCALE) + 0.5) as i32

        //

        // But check for overflow.

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

            .ok()

            .map(PangoUnits)

    }

    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(),

            })

            None

    }

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

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

}

fn compute_text_box(

    layout: &pango::Layout,

    x: f64,

    y: f64,

    gravity: pango::Gravity,

) -> Option<Rect> {

    #![allow(clippy::many_single_char_names)]

    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,

        )

    Some(Rect::new(x, y, x + w, y + h))

}

    fn layout(

        &self,

        layout_context: &LayoutContext,

        acquired_nodes: &mut AcquiredNodes<'_>,

    ) -> LayoutSpan {

        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 extents = compute_text_box(&layout, x, y, gravity);

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

            acquired_nodes,

            self.values.stroke_opacity().0,

            self.values.color().0,

            None,

            None,

            &layout_context.session,

        );

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

            acquired_nodes,

            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,

            gravity,

            extents,

            is_visible,

            x,

            y,

            paint_order,

            stroke,

            stroke_paint,

            fill_paint,

            text_rendering,

            values: self.values.clone(),

            link_target: self.link_target.clone(),

        }

    }

fn children_to_chunks(

    chunks: &mut Vec<Chunk>,

    node: &Node,

    acquired_nodes: &mut AcquiredNodes<'_>,

    cascaded: &CascadedValues<'_>,

    layout_context: &LayoutContext,

    dx: f64,

    dy: f64,

    depth: usize,

    link: Option<String>,

) {

    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(

                &child,

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

                chunks,

                dx,

                dy,

                depth,

                link.clone(),

            );

        } else {

            assert!(child.is_element());

            match *child.borrow_element_data() {

                ElementData::TSpan(ref tspan) => {

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

                    tspan.to_chunks(

                        &child,

                        acquired_nodes,

                        &cascaded,

                        layout_context,

                        chunks,

                        dx,

                        dy,

                        depth + 1,

                        link.clone(),

                    );

                }

                ElementData::Link(ref link) => {

                    // TSpan::default sets all offsets to 0,

                    // which is what we want in links.

                    //

                    // FIXME: This is the only place in the code where an element's method (TSpan::to_chunks)

                    // is called with a node that is not the element itself: here, `child` is a Link, not a TSpan.

                    //

                    // The code works because the `tspan` is dropped immediately after calling to_chunks and no

                    // references are retained for it.

                    let tspan = TSpan::default();

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

                    tspan.to_chunks(

                        &child,

                        acquired_nodes,

                        &cascaded,

                        layout_context,

                        chunks,

                        dx,

                        dy,

                        depth + 1,

                        link.link.clone(),

                    );

                }

                ElementData::TRef(ref tref) => {

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

                    tref.to_chunks(

                        &child,

                        acquired_nodes,

                        &cascaded,

                        chunks,

                        depth + 1,

                        layout_context,

                    );

                }

        dx = 0.0;

        dy = 0.0;

}

    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,

        node: &Node,

        values: Rc<ComputedValues>,

        dx: f64,

        dy: f64,

        depth: usize,

        link_target: Option<String>,

    ) -> Span {

        self.ensure_normalized_string(node, &values);

        Span::new(

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

            values,

            dx,

            dy,

            depth,

            link_target,

        )

    }

    fn to_chunks(

        &self,

        node: &Node,

        values: Rc<ComputedValues>,

        chunks: &mut [Chunk],

        dx: f64,

        dy: f64,

        depth: usize,

        link_target: Option<String>,

    ) {

        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()

    }

    fn make_chunks(

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        layout_context: &LayoutContext,

        x: f64,

        y: f64,

    ) -> Vec<Chunk> {

        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(

            &mut chunks,

            node,

            acquired_nodes,

            cascaded,

            layout_context,

            dx,

            dy,

            0,

            None,

        );

        chunks

    }

fn parse_list_and_extract_first<T: Copy + Default + Parse>(

    dest: &mut T,

    attr: QualName,

    value: &str,

    session: &Session,

) {

    let mut list: CommaSeparatedList<T, 0, 1024> = CommaSeparatedList(Vec::new());

    set_attribute(&mut list, attr.parse(value), session);

    if list.0.is_empty() {

    } else {

        *dest = list.0[0]; // ignore all but the first element

    }

}

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

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

            match attr.expanded() {

                    parse_list_and_extract_first(&mut self.x, attr, value, session)

                    parse_list_and_extract_first(&mut self.y, attr, value, session)

                    parse_list_and_extract_first(&mut self.dx, attr, value, session)

                    parse_list_and_extract_first(&mut self.dy, attr, value, session)

                _ => (),

    }

    fn layout(

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        viewport: &Viewport,

        draw_ctx: &mut DrawingCtx,

        _clipping: bool,

    ) -> Result<Option<Layer>, InternalRenderingError> {

        let values = cascaded.get();

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

        let elt = node.borrow_element();

        let session = draw_ctx.session().clone();

        let stacking_ctx = StackingContext::new(

            &session,

            acquired_nodes,

            &elt,

            values.transform(),

            None,

            values,

        );

        let layout_text = {

            let layout_context = LayoutContext {

                writing_mode: values.writing_mode(),

                font_options: draw_ctx.get_font_options(),

                viewport: *viewport,

                session: 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);

                let positioned =

                    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 text_extents: Option<Rect> = layout_spans

                .iter()

                .map(|span| span.extents)

                .reduce(|a, b| match (a, b) {

                    (None, None) => None,

                    (None, Some(b)) => Some(b),

                    (Some(a), None) => Some(a),

                    (Some(a), Some(b)) => Some(a.union(&b)),

                })

                .flatten();

            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(

                    &text_extents,

                    &layout_context.viewport,

                    &normalize_values,

                );

                let fill_paint = span.fill_paint.to_user_space(

                    &text_extents,

                    &layout_context.viewport,

                    &normalize_values,

                );

                let text_span = TextSpan {

                    layout: span.layout,

                    gravity: span.gravity,

                    extents: span.extents,

                    is_visible: span.is_visible,

                    x: span.x,

                    y: span.y,

                    paint_order: span.paint_order,

                    stroke: span.stroke,

                    stroke_paint,

                    fill_paint,

                    text_rendering: span.text_rendering,

                    link_target: span.link_target,

                };

                text_spans.push(text_span);

            }

            layout::Text {

                spans: text_spans,

                extents: text_extents,

            }

        };

        Ok(Some(Layer {

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

            stacking_ctx,

        }))

    }

    fn draw(

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        viewport: &Viewport,

        draw_ctx: &mut DrawingCtx,

        clipping: bool,

    ) -> Result<BoundingBox, InternalRenderingError> {

        self.layout(node, acquired_nodes, cascaded, viewport, draw_ctx, clipping)

            .and_then(|layer| {

                draw_ctx.draw_layer(layer.as_ref().unwrap(), acquired_nodes, clipping, viewport)

            })

    }

    fn to_chunks(

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        chunks: &mut Vec<Chunk>,

        depth: usize,

        layout_context: &LayoutContext,

    ) {

        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(

    chunks: &mut Vec<Chunk>,

    node: &Node,

    values: Rc<ComputedValues>,

    depth: usize,

) {

    for child in node.children() {

        let values = values.clone();

        if child.is_chars() {

            child

                .borrow_chars()

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

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

}

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

        self.link = attrs

            .iter()

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

            // Unlike other elements which use `href` in SVG2 versus `xlink:href` in SVG1.1,

            // the <tref> element got removed in SVG2.  So, here we still use a match

            // against the full namespaced version of the attribute.

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

    }

    fn to_chunks(

        &self,

        node: &Node,

        acquired_nodes: &mut AcquiredNodes<'_>,

        cascaded: &CascadedValues<'_>,

        layout_context: &LayoutContext,

        chunks: &mut Vec<Chunk>,

        dx: f64,

        dy: f64,

        depth: usize,

        link: Option<String>,

    ) {

        let values = cascaded.get();

        if !values.is_displayed() {

            return;

        }

        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(

            chunks,

            node,

            acquired_nodes,

            cascaded,

            layout_context,

            span_dx,

            span_dy,

            depth,

            link,

        );

    }

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

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

            match attr.expanded() {

                    parse_list_and_extract_first(&mut self.x, attr, value, session)

                    parse_list_and_extract_first(&mut self.y, attr, value, session)

                    parse_list_and_extract_first(&mut self.dx, attr, value, session)

                    parse_list_and_extract_first(&mut self.dy, attr, 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,

    }

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

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

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

            (Embed,           Rtl) => (&[RLE][..],      &[PDF][..]),

            (Isolate,         Rtl) => (&[RLI][..],      &[PDI][..]),

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

            (IsolateOverride, Ltr) => (&[FSI, LRO][..], &[PDF, PDI][..]),

        BidiControl { start, end }

    }

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

    let mut res =

        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(

    layout_context: &LayoutContext,

    props: &FontProperties,

    text: &str,

) -> Option<pango::Layout> {

    let pango_context = create_pango_context(&layout_context.font_options);

    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) {

        (UnicodeBidi::BidiOverride, _) | (UnicodeBidi::Embed, _) => {

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

        }