Grcov report - drawing

1

//! The main context structure which drives the drawing process.

2

3

use float_cmp::approx_eq;

4

use glib::translate::*;

5

use pango::ffi::PangoMatrix;

6

use pango::prelude::FontMapExt;

7

use regex::{Captures, Regex};

8

use std::cell::RefCell;

9

use std::convert::TryFrom;

10

use std::f64::consts::*;

11

use std::rc::Rc;

12

use std::{borrow::Cow, sync::OnceLock};

13

14

use crate::accept_language::UserLanguage;

15

use crate::aspect_ratio::AspectRatio;

16

use crate::bbox::BoundingBox;

17

use crate::color::color_to_rgba;

18

use crate::coord_units::CoordUnits;

19

use crate::document::{AcquiredNodes, NodeId};

20

use crate::dpi::Dpi;

21

use crate::element::{Element, ElementData};

22

use crate::error::{AcquireError, ImplementationLimit, InternalRenderingError};

23

use crate::filters::{self, FilterSpec};

24

use crate::float_eq_cairo::ApproxEqCairo;

25

use crate::gradient::{GradientVariant, SpreadMethod, UserSpaceGradient};

26

use crate::layout::{

27

    Filter, Image, Layer, LayerKind, Shape, StackingContext, Stroke, Text, TextSpan,

28

};

29

use crate::length::*;

30

use crate::marker;

31

use crate::node::{CascadedValues, Node, NodeBorrow, NodeDraw};

32

use crate::paint_server::{PaintSource, UserSpacePaintSource};

33

use crate::path_builder::*;

34

use crate::pattern::UserSpacePattern;

35

use crate::properties::{

36

    ClipRule, ComputedValues, FillRule, ImageRendering, MaskType, MixBlendMode, Opacity, Overflow,

37

    PaintTarget, ShapeRendering, StrokeLinecap, StrokeLinejoin, TextRendering,

38

};

39

use crate::rect::{rect_to_transform, IRect, Rect};

40

use crate::rsvg_log;

41

use crate::session::Session;

42

use crate::surface_utils::shared_surface::{

43

    ExclusiveImageSurface, Interpolation, SharedImageSurface, SurfaceType,

44

};

45

use crate::transform::{Transform, ValidTransform};

46

use crate::unit_interval::UnitInterval;

47

use crate::viewbox::ViewBox;

48

use crate::{borrow_element_as, is_element_of_type};

49

50

/// Opaque font options for a DrawingCtx.

51

///

52

/// This is used for DrawingCtx::create_pango_context.

53

pub struct FontOptions {

54

    options: cairo::FontOptions,

55

56

57

#[derive(Debug, Copy, Clone, PartialEq)]

58

pub enum ClipMode {

59

    ClipToViewport,

60

    NoClip,

61

62

63

/// Set path on the cairo context, or clear it.

64

/// This helper object keeps track whether the path has been set already,

65

/// so that it isn't recalculated every so often.

66

struct PathHelper<'a> {

67

    cr: &'a cairo::Context,

68

    transform: ValidTransform,

69

    path: &'a Path,

70

    is_square_linecap: bool,

71

    has_path: Option<bool>,

72

73

74

impl<'a> PathHelper<'a> {

75

948198

    pub fn new(

76

        cr: &'a cairo::Context,

77

        transform: ValidTransform,

78

        path: &'a Path,

79

        linecap: StrokeLinecap,

80

    ) -> Self {

81

948198

        PathHelper {

82

cr,

83

            transform,

84

            path,

85

948198

            is_square_linecap: linecap == StrokeLinecap::Square,

86

948198

            has_path: None,

87

88

948198

89

90

2843786

    pub fn set(&mut self) -> Result<(), InternalRenderingError> {

91

2843786

        match self.has_path {

92

            Some(false) | None => {

93

948648

                self.has_path = Some(true);

94

948648

                self.cr.set_matrix(self.transform.into());

95

948648

                self.path.to_cairo(self.cr, self.is_square_linecap)

96

97

1895138

            Some(true) => Ok(()),

98

99

2843786

100

101

1896191

    pub fn unset(&mut self) {

102

1896191

        match self.has_path {

103

            Some(true) | None => {

104

948783

                self.has_path = Some(false);

105

948783

                self.cr.new_path();

106

107

            Some(false) => {}

108

109

1896191

110

111

112

/// Holds the size of the current viewport in the user's coordinate system.

113

105588

#[derive(Clone)]

114

pub struct Viewport {

115

52794

    pub dpi: Dpi,

116

117

    /// Corners of the current coordinate space.

118

52794

    pub vbox: ViewBox,

119

120

    /// The viewport's coordinate system, or "user coordinate system" in SVG terms.

121

52794

    transform: Transform,

122

123

124

impl Viewport {

125

    /// FIXME: this is just used in Handle::with_height_to_user(), and in length.rs's test suite.

126

    /// Find a way to do this without involving a default identity transform.

127

166

    pub fn new(dpi: Dpi, view_box_width: f64, view_box_height: f64) -> Viewport {

128

166

        Viewport {

129

            dpi,

130

166

            vbox: ViewBox::from(Rect::from_size(view_box_width, view_box_height)),

131

166

            transform: Default::default(),

132

133

166

134

135

    /// Creates a new viewport suitable for a certain kind of units.

136

///

137

    /// For `objectBoundingBox`, CSS lengths which are in percentages

138

    /// refer to the size of the current viewport.  Librsvg implements

139

    /// that by keeping the same current transformation matrix, and

140

    /// setting a viewport size of (1.0, 1.0).

141

///

142

    /// For `userSpaceOnUse`, we just duplicate the current viewport,

143

    /// since that kind of units means to use the current coordinate

144

    /// system unchanged.

145

501224

    pub fn with_units(&self, units: CoordUnits) -> Viewport {

146

501224

        match units {

147

404

            CoordUnits::ObjectBoundingBox => Viewport {

148

404

                dpi: self.dpi,

149

404

                vbox: ViewBox::from(Rect::from_size(1.0, 1.0)),

150

404

                transform: self.transform,

151

404

},

152

153

500820

            CoordUnits::UserSpaceOnUse => Viewport {

154

500820

                dpi: self.dpi,

155

500820

                vbox: self.vbox,

156

500820

                transform: self.transform,

157

500820

},

158

159

501224

160

161

    /// Returns a viewport with a new size for normalizing `Length` values.

162

193

    pub fn with_view_box(&self, width: f64, height: f64) -> Viewport {

163

193

        Viewport {

164

193

            dpi: self.dpi,

165

193

            vbox: ViewBox::from(Rect::from_size(width, height)),

166

193

            transform: self.transform,

167

168

193

169

170

171

pub struct DrawingCtx {

172

    session: Session,

173

174

    initial_viewport: Viewport,

175

176

    dpi: Dpi,

177

178

    cr_stack: Rc<RefCell<Vec<cairo::Context>>>,

179

    cr: cairo::Context,

180

181

    user_language: UserLanguage,

182

183

    drawsub_stack: Vec<Node>,

184

185

    svg_nesting: SvgNesting,

186

187

    measuring: bool,

188

    testing: bool,

189

190

191

pub enum DrawingMode {

192

    LimitToStack { node: Node, root: Node },

193

194

    OnlyNode(Node),

195

196

197

/// Whether an SVG document is being rendered standalone or referenced from an `<image>` element.

198

///

199

/// Normally, the coordinate system used when rendering a toplevel SVG is determined from the

200

/// initial viewport and the `<svg>` element's `viewBox` and `preserveAspectRatio` attributes.

201

/// However, when an SVG document is referenced from an `<image>` element, as in `<image href="foo.svg"/>`,

202

/// its `preserveAspectRatio` needs to be ignored so that the one from the `<image>` element can

203

/// be used instead.  This lets the parent document (the one with the `<image>` element) specify

204

/// how it wants the child SVG to be scaled into the viewport.

205

#[derive(Copy, Clone)]

206

pub enum SvgNesting {

207

    Standalone,

208

    ReferencedFromImageElement,

209

210

211

/// The toplevel drawing routine.

212

///

213

/// This creates a DrawingCtx internally and starts drawing at the specified `node`.

214

1105

pub fn draw_tree(

215

    session: Session,

216

    mode: DrawingMode,

217

    cr: &cairo::Context,

218

    viewport_rect: Rect,

219

    user_language: &UserLanguage,

220

    dpi: Dpi,

221

    svg_nesting: SvgNesting,

222

    measuring: bool,

223

    testing: bool,

224

    acquired_nodes: &mut AcquiredNodes<'_>,

225

) -> Result<BoundingBox, InternalRenderingError> {

226

2230

    let (drawsub_stack, node) = match mode {

227

1087

        DrawingMode::LimitToStack { node, root } => (node.ancestors().collect(), root),

228

229

18

        DrawingMode::OnlyNode(node) => (Vec::new(), node),

230

};

231

232

1125

    let cascaded = CascadedValues::new_from_node(&node);

233

234

    // Preserve the user's transform and use it for the outermost bounding box.  All bounds/extents

235

    // will be converted to this transform in the end.

236

1103

    let user_transform = Transform::from(cr.matrix());

237

1100

    let mut user_bbox = BoundingBox::new().with_transform(user_transform);

238

239

    // https://www.w3.org/TR/SVG2/coords.html#InitialCoordinateSystem

240

//

241

    // "For the outermost svg element, the SVG user agent must

242

    // determine an initial viewport coordinate system and an

243

    // initial user coordinate system such that the two

244

    // coordinates systems are identical. The origin of both

245

    // coordinate systems must be at the origin of the SVG

246

    // viewport."

247

//

248

    // "... the initial viewport coordinate system (and therefore

249

    // the initial user coordinate system) must have its origin at

250

    // the top/left of the viewport"

251

252

    // Translate so (0, 0) is at the viewport's upper-left corner.

253

1105

    let transform = user_transform.pre_translate(viewport_rect.x0, viewport_rect.y0);

254

255

    // Here we exit immediately if the transform is not valid, since we are in the

256

    // toplevel drawing function.  Downstream cases would simply not render the current

257

    // element and ignore the error.

258

2210

    let valid_transform = ValidTransform::try_from(transform)?;

259

1102

    cr.set_matrix(valid_transform.into());

260

261

    // Per the spec, so the viewport has (0, 0) as upper-left.

262

1107

    let viewport_rect = viewport_rect.translate((-viewport_rect.x0, -viewport_rect.y0));

263

1105

    let initial_viewport = Viewport {

264

        dpi,

265

1107

        vbox: ViewBox::from(viewport_rect),

266

        transform,

267

};

268

269

1107

    let mut draw_ctx = DrawingCtx::new(

270

1105

        session,

271

cr,

272

        &initial_viewport,

273

1105

        user_language.clone(),

274

        dpi,

275

        svg_nesting,

276

        measuring,

277

        testing,

278

1107

        drawsub_stack,

279

1105

);

280

281

1105

    let content_bbox = draw_ctx.draw_node_from_stack(

282

        &node,

283

        acquired_nodes,

284

        &cascaded,

285

        &initial_viewport,

286

        false,

287

1

)?;

288

289

1104

    user_bbox.insert(&content_bbox);

290

291

1104

    Ok(user_bbox)

292

1105

293

294

2008847

pub fn with_saved_cr<O, F>(cr: &cairo::Context, f: F) -> Result<O, InternalRenderingError>

295

where

296

    F: FnOnce() -> Result<O, InternalRenderingError>,

297

298

2008847

    cr.save()?;

299

2005217

    match f() {

300

2007446

        Ok(o) => {

301

4017301

            cr.restore()?;

302

2008134

            Ok(o)

303

2008134

304

305

37

        Err(e) => Err(e),

306

307

2008171

308

309

impl Drop for DrawingCtx {

310

51883

    fn drop(&mut self) {

311

51883

        self.cr_stack.borrow_mut().pop();

312

51881

313

314

315

const CAIRO_TAG_LINK: &str = "Link";

316

317

impl DrawingCtx {

318

1103

    fn new(

319

        session: Session,

320

        cr: &cairo::Context,

321

        initial_viewport: &Viewport,

322

        user_language: UserLanguage,

323

        dpi: Dpi,

324

        svg_nesting: SvgNesting,

325

        measuring: bool,

326

        testing: bool,

327

        drawsub_stack: Vec<Node>,

328

    ) -> DrawingCtx {

329

1101

        DrawingCtx {

330

1105

            session,

331

1105

            initial_viewport: initial_viewport.clone(),

332

            dpi,

333

1104

            cr_stack: Rc::new(RefCell::new(Vec::new())),

334

1101

            cr: cr.clone(),

335

1101

            user_language,

336

1101

            drawsub_stack,

337

            svg_nesting,

338

            measuring,

339

            testing,

340

341

1101

342

343

    /// Copies a `DrawingCtx` for temporary use on a Cairo surface.

344

///

345

    /// `DrawingCtx` maintains state using during the drawing process, and sometimes we

346

    /// would like to use that same state but on a different Cairo surface and context

347

    /// than the ones being used on `self`.  This function copies the `self` state into a

348

    /// new `DrawingCtx`, and ties the copied one to the supplied `cr`.

349

50778

    fn nested(&self, cr: cairo::Context) -> DrawingCtx {

350

50778

        let cr_stack = self.cr_stack.clone();

351

352

50778

        cr_stack.borrow_mut().push(self.cr.clone());

353

354

50778

        DrawingCtx {

355

50778

            session: self.session.clone(),

356

50778

            initial_viewport: self.initial_viewport.clone(),

357

50778

            dpi: self.dpi,

358

50778

            cr_stack,

359

50778

cr,

360

50778

            user_language: self.user_language.clone(),

361

50778

            drawsub_stack: self.drawsub_stack.clone(),

362

50778

            svg_nesting: self.svg_nesting,

363

50778

            measuring: self.measuring,

364

50778

            testing: self.testing,

365

366

50778

367

368

7841246

    pub fn session(&self) -> &Session {

369

7841246

        &self.session

370

7841246

371

372

33

    pub fn user_language(&self) -> &UserLanguage {

373

33

        &self.user_language

374

33

375

376

1738

    pub fn toplevel_viewport(&self) -> Rect {

377

1738

        *self.initial_viewport.vbox

378

1738

379

380

    /// Gets the transform that will be used on the target surface,

381

    /// whether using an isolated stacking context or not.

382

///

383

    /// This is only used in the text code, and we should probably try

384

    /// to remove it.

385

948998

    pub fn get_transform_for_stacking_ctx(

386

        &self,

387

        stacking_ctx: &StackingContext,

388

        clipping: bool,

389

    ) -> Result<ValidTransform, InternalRenderingError> {

390

949425

        if stacking_ctx.should_isolate() && !clipping {

391

427

            let affines = CompositingAffines::new(

392

427

                *self.get_transform(),

393

427

                self.initial_viewport.transform,

394

427

                self.cr_stack.borrow().len(),

395

427

);

396

397

949425

            Ok(ValidTransform::try_from(affines.for_temporary_surface)?)

398

        } else {

399

948571

            Ok(self.get_transform())

400

401

948998

402

403

1119

    pub fn svg_nesting(&self) -> SvgNesting {

404

1119

        self.svg_nesting

405

1119

406

407

1082

    pub fn is_measuring(&self) -> bool {

408

1082

        self.measuring

409

1082

410

411

14

    pub fn is_testing(&self) -> bool {

412

14

        self.testing

413

14

414

415

9457532

    pub fn get_transform(&self) -> ValidTransform {

416

9457532

        let t = Transform::from(self.cr.matrix());

417

9457532

        ValidTransform::try_from(t)

418

            .expect("Cairo should already have checked that its current transform is valid")

419

9457532

420

421

3512906

    pub fn empty_bbox(&self) -> BoundingBox {

422

3512906

        BoundingBox::new().with_transform(*self.get_transform())

423

3512906

424

425

740

    fn size_for_temporary_surface(&self) -> (i32, i32) {

426

740

        let rect = self.toplevel_viewport();

427

428

740

        let (viewport_width, viewport_height) = (rect.width(), rect.height());

429

430

740

        let (width, height) = self

431

            .initial_viewport

432

            .transform

433

            .transform_distance(viewport_width, viewport_height);

434

435

        // We need a size in whole pixels, so use ceil() to ensure the whole viewport fits

436

        // into the temporary surface.

437

740

        (width.ceil().abs() as i32, height.ceil().abs() as i32)

438

740

439

440

360

    pub fn create_surface_for_toplevel_viewport(

441

        &self,

442

    ) -> Result<cairo::ImageSurface, InternalRenderingError> {

443

360

        let (w, h) = self.size_for_temporary_surface();

444

445

360

        Ok(cairo::ImageSurface::create(cairo::Format::ARgb32, w, h)?)

446

360

447

448

380

    fn create_similar_surface_for_toplevel_viewport(

449

        &self,

450

        surface: &cairo::Surface,

451

    ) -> Result<cairo::Surface, InternalRenderingError> {

452

380

        let (w, h) = self.size_for_temporary_surface();

453

454

380

        Ok(cairo::Surface::create_similar(

455

            surface,

456

380

            cairo::Content::ColorAlpha,

457

w,

458

h,

459

)?)

460

380

461

462

    /// Creates a new coordinate space inside a viewport and sets a clipping rectangle.

463

///

464

    /// Note that this actually changes the `draw_ctx.cr`'s transformation to match

465

    /// the new coordinate space, but the old one is not restored after the

466

    /// result's `Viewport` is dropped.  Thus, this function must be called

467

    /// inside `with_saved_cr` or `draw_ctx.with_discrete_layer`.

468

1238

    pub fn push_new_viewport(

469

        &self,

470

        current_viewport: &Viewport,

471

        vbox: Option<ViewBox>,

472

        viewport_rect: Rect,

473

        preserve_aspect_ratio: AspectRatio,

474

        clip_mode: ClipMode,

475

    ) -> Option<Viewport> {

476

1238

        if let ClipMode::ClipToViewport = clip_mode {

477

49

            clip_to_rectangle(&self.cr, &viewport_rect);

478

479

480

3714

        preserve_aspect_ratio

481

1238

            .viewport_to_viewbox_transform(vbox, &viewport_rect)

482

1240

            .unwrap_or_else(|_e| {

483

2

                match vbox {

484

                    None => unreachable!(

485

                        "viewport_to_viewbox_transform only returns errors when vbox != None"

486

),

487

2

                    Some(v) => {

488

2

                        rsvg_log!(

489

2

                            self.session,

490

                            "ignoring viewBox ({}, {}, {}, {}) since it is not usable",

491

                            v.x0,

492

                            v.y0,

493

                            v.width(),

494

                            v.height()

495

);

496

497

498

2

                None

499

2

})

500

2471

            .map(|t| {

501

1233

                self.cr.transform(t.into());

502

503

1233

                Viewport {

504

1233

                    dpi: self.dpi,

505

1233

                    vbox: vbox.unwrap_or(current_viewport.vbox),

506

1233

                    transform: current_viewport.transform.post_transform(&t),

507

508

1233

})

509

1238

510

511

2006161

    fn clip_to_node(

512

        &mut self,

513

        clip_node: &Option<Node>,

514

        acquired_nodes: &mut AcquiredNodes<'_>,

515

        viewport: &Viewport,

516

        bbox: &BoundingBox,

517

    ) -> Result<(), InternalRenderingError> {

518

2006161

        if clip_node.is_none() {

519

2006032

            return Ok(());

520

521

522

129

        let node = clip_node.as_ref().unwrap();

523

129

        let units = borrow_element_as!(node, ClipPath).get_units();

524

525

129

        if let Ok(transform) = rect_to_transform(&bbox.rect, units) {

526

127

            let cascaded = CascadedValues::new_from_node(node);

527

127

            let values = cascaded.get();

528

529

43

            let node_transform = values.transform().post_transform(&transform);

530

2006204

            let transform_for_clip = ValidTransform::try_from(node_transform)?;

531

532

42

            let orig_transform = self.get_transform();

533

42

            self.cr.transform(transform_for_clip.into());

534

535

168

            for child in node.children().filter(|c| {

536

126

                c.is_element() && element_can_be_used_inside_clip_path(&c.borrow_element())

537

126

            }) {

538

42

                child.draw(

539

                    acquired_nodes,

540

42

                    &CascadedValues::clone_with_node(&cascaded, &child),

541

                    viewport,

542

                    self,

543

                    true,

544

42

)?;

545

42

546

547

42

            self.cr.clip();

548

549

42

            self.cr.set_matrix(orig_transform.into());

550

43

551

552

44

        Ok(())

553

2006077

554

555

60

    fn generate_cairo_mask(

556

        &mut self,

557

        mask_node: &Node,

558

        viewport: &Viewport,

559

        transform: Transform,

560

        bbox: &BoundingBox,

561

        acquired_nodes: &mut AcquiredNodes<'_>,

562

    ) -> Result<Option<cairo::ImageSurface>, InternalRenderingError> {

563

60

        if bbox.rect.is_none() {

564

            // The node being masked is empty / doesn't have a

565

            // bounding box, so there's nothing to mask!

566

1

            return Ok(None);

567

568

569

59

        let _mask_acquired = match acquired_nodes.acquire_ref(mask_node) {

570

59

            Ok(n) => n,

571

572

            Err(AcquireError::CircularReference(_)) => {

573

                rsvg_log!(self.session, "circular reference in element {}", mask_node);

574

                return Ok(None);

575

576

577

            _ => unreachable!(),

578

59

};

579

580

59

        let mask_element = mask_node.borrow_element();

581

59

        let mask = borrow_element_as!(mask_node, Mask);

582

583

59

        let bbox_rect = bbox.rect.as_ref().unwrap();

584

585

59

        let cascaded = CascadedValues::new_from_node(mask_node);

586

59

        let values = cascaded.get();

587

588

59

        let mask_units = mask.get_units();

589

590

        let mask_rect = {

591

59

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

592

59

            mask.get_rect(&params)

593

};

594

595

59

        let mask_transform = values.transform().post_transform(&transform);

596

59

        let transform_for_mask = ValidTransform::try_from(mask_transform)?;

597

598

59

        let mask_content_surface = self.create_surface_for_toplevel_viewport()?;

599

600

        // Use a scope because mask_cr needs to release the

601

        // reference to the surface before we access the pixels

602

603

59

            let mask_cr = cairo::Context::new(&mask_content_surface)?;

604

59

            mask_cr.set_matrix(transform_for_mask.into());

605

606

59

            let bbtransform = Transform::new_unchecked(

607

59

                bbox_rect.width(),

608

                0.0,

609

                0.0,

610

59

                bbox_rect.height(),

611

59

                bbox_rect.x0,

612

59

                bbox_rect.y0,

613

);

614

615

59

            let clip_rect = if mask_units == CoordUnits::ObjectBoundingBox {

616

10

                bbtransform.transform_rect(&mask_rect)

617

            } else {

618

49

                mask_rect

619

};

620

621

59

            clip_to_rectangle(&mask_cr, &clip_rect);

622

623

59

            if mask.get_content_units() == CoordUnits::ObjectBoundingBox {

624

5

                if bbox_rect.is_empty() {

625

1

                    return Ok(None);

626

627

64

                mask_cr.transform(ValidTransform::try_from(bbtransform)?.into());

628

629

630

58

            let mask_viewport = viewport.with_units(mask.get_content_units());

631

632

58

            let mut mask_draw_ctx = self.nested(mask_cr);

633

634

58

            let stacking_ctx = StackingContext::new(

635

58

                self.session(),

636

                acquired_nodes,

637

58

                &mask_element,

638

58

                Transform::identity(),

639

58

                None,

640

                values,

641

);

642

643

58

            rsvg_log!(self.session, "(mask {}", mask_element);

644

645

58

            let res = mask_draw_ctx.with_discrete_layer(

646

                &stacking_ctx,

647

                acquired_nodes,

648

                &mask_viewport,

649

                false,

650

116

                &mut |an, dc| mask_node.draw_children(an, &cascaded, &mask_viewport, dc, false),

651

58

);

652

653

58

            rsvg_log!(self.session, ")");

654

655

58

            res?;

656

59

657

658

58

        let tmp = SharedImageSurface::wrap(mask_content_surface, SurfaceType::SRgb)?;

659

660

58

        let mask_result = match values.mask_type() {

661

57

            MaskType::Luminance => tmp.to_luminance_mask()?,

662

1

            MaskType::Alpha => tmp.extract_alpha(IRect::from_size(tmp.width(), tmp.height()))?,

663

};

664

665

58

        let mask = mask_result.into_image_surface()?;

666

667

58

        Ok(Some(mask))

668

60

669

670

2006101

    pub fn with_discrete_layer(

671

        &mut self,

672

        stacking_ctx: &StackingContext,

673

        acquired_nodes: &mut AcquiredNodes<'_>,

674

        viewport: &Viewport,

675

        clipping: bool,

676

        draw_fn: &mut dyn FnMut(

677

            &mut AcquiredNodes<'_>,

678

            &mut DrawingCtx,

679

        ) -> Result<BoundingBox, InternalRenderingError>,

680

    ) -> Result<BoundingBox, InternalRenderingError> {

681

2006101

        let stacking_ctx_transform = ValidTransform::try_from(stacking_ctx.transform)?;

682

683

2006100

        let orig_transform = self.get_transform();

684

2006100

        self.cr.transform(stacking_ctx_transform.into());

685

686

2006100

        let res = if clipping {

687

40

            draw_fn(acquired_nodes, self)

688

        } else {

689

4008587

            with_saved_cr(&self.cr.clone(), || {

690

2002527

                if let Some(ref link_target) = stacking_ctx.link_target {

691

2

                    self.link_tag_begin(link_target);

692

693

694

2002527

                let Opacity(UnitInterval(opacity)) = stacking_ctx.opacity;

695

696

2002527

                let affine_at_start = self.get_transform();

697

698

2002527

                if let Some(rect) = stacking_ctx.clip_rect.as_ref() {

699

184

                    clip_to_rectangle(&self.cr, rect);

700

701

702

                // Here we are clipping in user space, so the bbox doesn't matter

703

4005054

                self.clip_to_node(

704

2002527

                    &stacking_ctx.clip_in_user_space,

705

2002527

                    acquired_nodes,

706

2002527

                    viewport,

707

2002527

                    &self.empty_bbox(),

708

1

)?;

709

710

2002526

                let should_isolate = stacking_ctx.should_isolate();

711

712

2003207

                let res = if should_isolate {

713

                    // Compute our assortment of affines

714

715

681

                    let affines = CompositingAffines::new(

716

681

                        *affine_at_start,

717

681

                        self.initial_viewport.transform,

718

681

                        self.cr_stack.borrow().len(),

719

681

);

720

721

                    // Create temporary surface and its cr

722

723

681

                    let cr = match stacking_ctx.filter {

724

380

                        None => cairo::Context::new(

725

760

                            &self

726

380

                                .create_similar_surface_for_toplevel_viewport(&self.cr.target())?,

727

380

)?,

728

                        Some(_) => {

729

301

                            cairo::Context::new(self.create_surface_for_toplevel_viewport()?)?

730

301

731

};

732

733

681

                    cr.set_matrix(ValidTransform::try_from(affines.for_temporary_surface)?.into());

734

735

681

                    let (source_surface, mut res, bbox) = {

736

681

                        let mut temporary_draw_ctx = self.nested(cr);

737

738

                        // Draw!

739

740

681

                        let res = draw_fn(acquired_nodes, &mut temporary_draw_ctx);

741

742

681

                        let bbox = if let Ok(ref bbox) = res {

743

681

                            *bbox

744

                        } else {

745

                            BoundingBox::new().with_transform(affines.for_temporary_surface)

746

};

747

748

1362

                        if let Some(ref filter) = stacking_ctx.filter {

749

301

                            let surface_to_filter = SharedImageSurface::copy_from_surface(

750

301

                                &cairo::ImageSurface::try_from(temporary_draw_ctx.cr.target())

751

                                    .unwrap(),

752

301

)?;

753

754

                            let stroke_paint_source =

755

301

                                Rc::new(filter.stroke_paint_source.to_user_space(

756

                                    &bbox.rect,

757

301

                                    viewport,

758

301

                                    &filter.normalize_values,

759

301

));

760

                            let fill_paint_source =

761

301

                                Rc::new(filter.fill_paint_source.to_user_space(

762

                                    &bbox.rect,

763

301

                                    viewport,

764

301

                                    &filter.normalize_values,

765

301

));

766

767

                            // Filter functions (like "blend()", not the <filter> element) require

768

                            // being resolved in userSpaceonUse units, since that is the default

769

                            // for primitive_units.  So, get the corresponding NormalizeParams

770

                            // here and pass them down.

771

301

                            let user_space_params = NormalizeParams::from_values(

772

301

                                &filter.normalize_values,

773

301

                                &viewport.with_units(CoordUnits::UserSpaceOnUse),

774

);

775

776

301

                            let filtered_surface = temporary_draw_ctx

777

                                .run_filters(

778

301

                                    viewport,

779

301

                                    surface_to_filter,

780

                                    filter,

781

301

                                    acquired_nodes,

782

301

                                    &stacking_ctx.element_name,

783

                                    &user_space_params,

784

301

                                    stroke_paint_source,

785

301

                                    fill_paint_source,

786

301

                                    bbox,

787

301

)?

788

                                .into_image_surface()?;

789

790

301

                            let generic_surface: &cairo::Surface = &filtered_surface; // deref to Surface

791

792

301

                            (generic_surface.clone(), res, bbox)

793

301

                        } else {

794

380

                            (temporary_draw_ctx.cr.target(), res, bbox)

795

796

681

};

797

798

                    // Set temporary surface as source

799

800

1362

                    self.cr

801

681

                        .set_matrix(ValidTransform::try_from(affines.compositing)?.into());

802

681

                    self.cr.set_source_surface(&source_surface, 0.0, 0.0)?;

803

804

                    // Clip

805

806

1362

                    self.cr.set_matrix(

807

681

                        ValidTransform::try_from(affines.outside_temporary_surface)?.into(),

808

);

809

1362

                    self.clip_to_node(

810

681

                        &stacking_ctx.clip_in_object_space,

811

681

                        acquired_nodes,

812

681

                        viewport,

813

                        &bbox,

814

)?;

815

816

                    // Mask

817

818

681

                    if let Some(ref mask_node) = stacking_ctx.mask {

819

120

                        res = res.and_then(|bbox| {

820

240

                            self.generate_cairo_mask(

821

60

                                mask_node,

822

60

                                viewport,

823

60

                                affines.for_temporary_surface,

824

                                &bbox,

825

60

                                acquired_nodes,

826

827

120

                            .and_then(|mask_surf| {

828

60

                                if let Some(surf) = mask_surf {

829

58

                                    self.cr.push_group();

830

831

116

                                    self.cr.set_matrix(

832

58

                                        ValidTransform::try_from(affines.compositing)?.into(),

833

);

834

58

                                    self.cr.mask_surface(&surf, 0.0, 0.0)?;

835

836

118

                                    Ok(self.cr.pop_group_to_source()?)

837

58

                                } else {

838

2

                                    Ok(())

839

840

60

})

841

120

                            .map(|_: ()| bbox)

842

60

});

843

844

845

846

                        // Composite the temporary surface

847

848

1362

                        self.cr

849

681

                            .set_matrix(ValidTransform::try_from(affines.compositing)?.into());

850

681

                        self.cr.set_operator(stacking_ctx.mix_blend_mode.into());

851

852

681

                        if opacity < 1.0 {

853

313

                            self.cr.paint_with_alpha(opacity)?;

854

                        } else {

855

368

                            self.cr.paint()?;

856

857

858

859

681

                    self.cr.set_matrix(affine_at_start.into());

860

681

res

861

681

                } else {

862

2001845

                    draw_fn(acquired_nodes, self)

863

};

864

865

2002526

                if stacking_ctx.link_target.is_some() {

866

2

                    self.link_tag_end();

867

868

869

2002526

res

870

2002527

})

871

2006060

};

872

873

2006100

        self.cr.set_matrix(orig_transform.into());

874

2006100

res

875

2006101

876

877

    /// Run the drawing function with the specified opacity

878

50026

    fn with_alpha(

879

        &mut self,

880

        opacity: UnitInterval,

881

        draw_fn: &mut dyn FnMut(&mut DrawingCtx) -> Result<BoundingBox, InternalRenderingError>,

882

    ) -> Result<BoundingBox, InternalRenderingError> {

883

50026

        let res;

884

50026

        let UnitInterval(o) = opacity;

885

100051

        if o < 1.0 {

886

1

            self.cr.push_group();

887

1

            res = draw_fn(self);

888

1

            self.cr.pop_group_to_source()?;

889

50027

            self.cr.paint_with_alpha(o)?;

890

        } else {

891

50025

            res = draw_fn(self);

892

893

894

50026

res

895

50026

896

897

    /// Start a Cairo tag for PDF links

898

6

    fn link_tag_begin(&mut self, link_target: &str) {

899

6

        let attributes = format!("uri='{}'", escape_link_target(link_target));

900

901

6

        let cr = self.cr.clone();

902

6

        cr.tag_begin(CAIRO_TAG_LINK, &attributes);

903

6

904

905

    /// End a Cairo tag for PDF links

906

6

    fn link_tag_end(&mut self) {

907

6

        self.cr.tag_end(CAIRO_TAG_LINK);

908

6

909

910

301

    fn run_filters(

911

        &mut self,

912

        viewport: &Viewport,

913

        surface_to_filter: SharedImageSurface,

914

        filter: &Filter,

915

        acquired_nodes: &mut AcquiredNodes<'_>,

916

        node_name: &str,

917

        user_space_params: &NormalizeParams,

918

        stroke_paint_source: Rc<UserSpacePaintSource>,

919

        fill_paint_source: Rc<UserSpacePaintSource>,

920

        node_bbox: BoundingBox,

921

    ) -> Result<SharedImageSurface, InternalRenderingError> {

922

301

        let session = self.session();

923

924

        // We try to convert each item in the filter_list to a FilterSpec.

925

//

926

        // However, the spec mentions, "If the filter references a non-existent object or

927

        // the referenced object is not a filter element, then the whole filter chain is

928

        // ignored." - https://www.w3.org/TR/filter-effects/#FilterProperty

929

//

930

        // So, run through the filter_list and collect into a Result<Vec<FilterSpec>>.

931

        // This will return an Err if any of the conversions failed.

932

301

        let filter_specs = filter

933

            .filter_list

934

            .iter()

935

605

            .map(|filter_value| {

936

304

                filter_value.to_filter_spec(

937

304

                    acquired_nodes,

938

304

                    user_space_params,

939

304

                    filter.current_color,

940

304

                    viewport,

941

304

                    session,

942

304

                    node_name,

943

944

304

})

945

            .collect::<Result<Vec<FilterSpec>, _>>();

946

947

301

        match filter_specs {

948

298

            Ok(specs) => {

949

                // Start with the surface_to_filter, and apply each filter spec in turn;

950

                // the final result is our return value.

951

597

                specs.iter().try_fold(surface_to_filter, |surface, spec| {

952

299

                    filters::render(

953

299

                        spec,

954

299

                        stroke_paint_source.clone(),

955

299

                        fill_paint_source.clone(),

956

299

                        surface,

957

299

                        acquired_nodes,

958

299

                        self,

959

299

                        *self.get_transform(),

960

299

                        node_bbox,

961

299

962

299

})

963

298

964

965

3

            Err(e) => {

966

3

                rsvg_log!(

967

3

                    self.session,

968

                    "not rendering filter list on node {} because it was in error: {}",

969

                    node_name,

970

971

);

972

                // just return the original surface without filtering it

973

3

                Ok(surface_to_filter)

974

975

976

301

977

978

163

    fn set_gradient(&mut self, gradient: &UserSpaceGradient) -> Result<(), InternalRenderingError> {

979

163

        let g = match gradient.variant {

980

128

            GradientVariant::Linear { x1, y1, x2, y2 } => {

981

128

                cairo::Gradient::clone(&cairo::LinearGradient::new(x1, y1, x2, y2))

982

128

983

984

            GradientVariant::Radial {

985

35

cx,

986

35

cy,

987

35

r,

988

35

fx,

989

35

fy,

990

35

fr,

991

35

            } => cairo::Gradient::clone(&cairo::RadialGradient::new(fx, fy, fr, cx, cy, r)),

992

};

993

994

163

        g.set_matrix(ValidTransform::try_from(gradient.transform)?.into());

995

163

        g.set_extend(cairo::Extend::from(gradient.spread));

996

997

618

        for stop in &gradient.stops {

998

455

            let UnitInterval(stop_offset) = stop.offset;

999

1000

455

            let rgba = color_to_rgba(&stop.color);

1001

1002

455

            g.add_color_stop_rgba(

1003

                stop_offset,

1004

455

                f64::from(rgba.red.unwrap_or(0)) / 255.0,

1005

455

                f64::from(rgba.green.unwrap_or(0)) / 255.0,

1006

455

                f64::from(rgba.blue.unwrap_or(0)) / 255.0,

1007

455

                f64::from(rgba.alpha.unwrap_or(0.0)),

1008

);

1009

1010

1011

326

        Ok(self.cr.set_source(&g)?)

1012

163

1013

1014

500033

    fn set_pattern(

1015

        &mut self,

1016

        pattern: &UserSpacePattern,

1017

        acquired_nodes: &mut AcquiredNodes<'_>,

1018

    ) -> Result<bool, InternalRenderingError> {

1019

        // Bail out early if the pattern has zero size, per the spec

1020

500033

        if approx_eq!(f64, pattern.width, 0.0) || approx_eq!(f64, pattern.height, 0.0) {

1021

9

            return Ok(false);

1022

1023

1024

        // Bail out early if this pattern has a circular reference

1025

500024

        let pattern_node_acquired = match pattern.acquire_pattern_node(acquired_nodes) {

1026

500024

            Ok(n) => n,

1027

1028

            Err(AcquireError::CircularReference(ref node)) => {

1029

                rsvg_log!(self.session, "circular reference in element {}", node);

1030

                return Ok(false);

1031

1032

1033

            _ => unreachable!(),

1034

500024

};

1035

1036

500024

        let pattern_node = pattern_node_acquired.get();

1037

1038

500024

        let taffine = self.get_transform().pre_transform(&pattern.transform);

1039

1040

500024

        let mut scwscale = (taffine.xx.powi(2) + taffine.xy.powi(2)).sqrt();

1041

500024

        let mut schscale = (taffine.yx.powi(2) + taffine.yy.powi(2)).sqrt();

1042

1043

500024

        let pw: i32 = (pattern.width * scwscale) as i32;

1044

500024

        let ph: i32 = (pattern.height * schscale) as i32;

1045

1046

500024

        if pw < 1 || ph < 1 {

1047

449998

            return Ok(false);

1048

1049

1050

50026

        scwscale = f64::from(pw) / pattern.width;

1051

50026

        schscale = f64::from(ph) / pattern.height;

1052

1053

        // Apply the pattern transform

1054

100029

        let (affine, caffine) = if scwscale.approx_eq_cairo(1.0) && schscale.approx_eq_cairo(1.0) {

1055

23

            (pattern.coord_transform, pattern.content_transform)

1056

        } else {

1057

50003

1058

100006

                pattern

1059

                    .coord_transform

1060

50003

                    .pre_scale(1.0 / scwscale, 1.0 / schscale),

1061

50003

                pattern.content_transform.post_scale(scwscale, schscale),

1062

1063

};

1064

1065

        // Draw to another surface

1066

50026

        let surface = self

1067

.cr

1068

            .target()

1069

100052

            .create_similar(cairo::Content::ColorAlpha, pw, ph)?;

1070

1071

50026

        let cr_pattern = cairo::Context::new(&surface)?;

1072

1073

        // Set up transformations to be determined by the contents units

1074

1075

50026

        let transform = ValidTransform::try_from(caffine)?;

1076

50026

        cr_pattern.set_matrix(transform.into());

1077

1078

        // Draw everything

1079

1080

1081

50026

            let mut pattern_draw_ctx = self.nested(cr_pattern);

1082

1083

50026

            let pattern_viewport = Viewport {

1084

50026

                dpi: self.dpi,

1085

50026

                vbox: ViewBox::from(Rect::from_size(pattern.width, pattern.height)),

1086

50026

                transform: *transform,

1087

};

1088

1089

50026

            pattern_draw_ctx

1090

100052

                .with_alpha(pattern.opacity, &mut |dc| {

1091

50026

                    let pattern_cascaded = CascadedValues::new_from_node(pattern_node);

1092

50026

                    let pattern_values = pattern_cascaded.get();

1093

1094

50026

                    let elt = pattern_node.borrow_element();

1095

1096

50026

                    let stacking_ctx = StackingContext::new(

1097

50026

                        self.session(),

1098

50026

                        acquired_nodes,

1099

50026

                        &elt,

1100

50026

                        Transform::identity(),

1101

50026

                        None,

1102

                        pattern_values,

1103

);

1104

1105

50026

                    dc.with_discrete_layer(

1106

                        &stacking_ctx,

1107

50026

                        acquired_nodes,

1108

50026

                        &pattern_viewport,

1109

                        false,

1110

100052

                        &mut |an, dc| {

1111

100052

                            pattern_node.draw_children(

1112

an,

1113

50026

                                &pattern_cascaded,

1114

50026

                                &pattern_viewport,

1115

dc,

1116

                                false,

1117

1118

50026

},

1119

1120

50026

})

1121

50026

                .map(|_| ())?;

1122

50026

1123

1124

        // Set the final surface as a Cairo pattern into the Cairo context

1125

50026

        let pattern = cairo::SurfacePattern::create(&surface);

1126

1127

50026

        if let Some(m) = affine.invert() {

1128

50026

            pattern.set_matrix(ValidTransform::try_from(m)?.into());

1129

50026

            pattern.set_extend(cairo::Extend::Repeat);

1130

50026

            pattern.set_filter(cairo::Filter::Best);

1131

550059

            self.cr.set_source(&pattern)?;

1132

1133

1134

50026

        Ok(true)

1135

500033

1136

1137

1899149

    fn set_paint_source(

1138

        &mut self,

1139

        paint_source: &UserSpacePaintSource,

1140

        acquired_nodes: &mut AcquiredNodes<'_>,

1141

    ) -> Result<bool, InternalRenderingError> {

1142

1899149

        match *paint_source {

1143

163

            UserSpacePaintSource::Gradient(ref gradient, _c) => {

1144

1899149

                self.set_gradient(gradient)?;

1145

163

                Ok(true)

1146

163

1147

500033

            UserSpacePaintSource::Pattern(ref pattern, ref c) => {

1148

500033

                if self.set_pattern(pattern, acquired_nodes)? {

1149

50026

                    Ok(true)

1150

450007

                } else if let Some(c) = c {

1151

9

                    set_source_color_on_cairo(&self.cr, c);

1152

9

                    Ok(true)

1153

                } else {

1154

449998

                    Ok(false)

1155

1156

1157

949673

            UserSpacePaintSource::SolidColor(ref c) => {

1158

949673

                set_source_color_on_cairo(&self.cr, c);

1159

949673

                Ok(true)

1160

949673

1161

449280

            UserSpacePaintSource::None => Ok(false),

1162

1163

1899149

1164

1165

    /// Computes and returns a surface corresponding to the given paint server.

1166

13

    pub fn get_paint_source_surface(

1167

        &mut self,

1168

        width: i32,

1169

        height: i32,

1170

        acquired_nodes: &mut AcquiredNodes<'_>,

1171

        paint_source: &UserSpacePaintSource,

1172

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1173

13

        let mut surface = ExclusiveImageSurface::new(width, height, SurfaceType::SRgb)?;

1174

1175

26

        surface.draw(&mut |cr| {

1176

13

            let mut temporary_draw_ctx = self.nested(cr);

1177

1178

            // FIXME: we are ignoring any error

1179

1180

            let had_paint_server =

1181

13

                temporary_draw_ctx.set_paint_source(paint_source, acquired_nodes)?;

1182

13

            if had_paint_server {

1183

26

                temporary_draw_ctx.cr.paint()?;

1184

1185

1186

13

            Ok(())

1187

13

        })?;

1188

1189

13

        Ok(surface.share()?)

1190

13

1191

1192

948589

    fn stroke(

1193

        &mut self,

1194

        cr: &cairo::Context,

1195

        acquired_nodes: &mut AcquiredNodes<'_>,

1196

        paint_source: &UserSpacePaintSource,

1197

    ) -> Result<(), InternalRenderingError> {

1198

948589

        let had_paint_server = self.set_paint_source(paint_source, acquired_nodes)?;

1199

948589

        if had_paint_server {

1200

1449736

            cr.stroke_preserve()?;

1201

1202

1203

948589

        Ok(())

1204

948589

1205

1206

948306

    fn fill(

1207

        &mut self,

1208

        cr: &cairo::Context,

1209

        acquired_nodes: &mut AcquiredNodes<'_>,

1210

        paint_source: &UserSpacePaintSource,

1211

    ) -> Result<(), InternalRenderingError> {

1212

948306

        let had_paint_server = self.set_paint_source(paint_source, acquired_nodes)?;

1213

948306

        if had_paint_server {

1214

1446570

            cr.fill_preserve()?;

1215

1216

1217

948306

        Ok(())

1218

948306

1219

1220

949123

    pub fn compute_path_extents(

1221

        &self,

1222

        path: &Path,

1223

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

1224

949123

        if path.is_empty() {

1225

18

            return Ok(None);

1226

1227

1228

949105

        let surface = cairo::RecordingSurface::create(cairo::Content::ColorAlpha, None)?;

1229

949105

        let cr = cairo::Context::new(&surface)?;

1230

1231

1898168

        path.to_cairo(&cr, false)?;

1232

948218

        let (x0, y0, x1, y1) = cr.path_extents()?;

1233

1234

948227

        Ok(Some(Rect::new(x0, y0, x1, y1)))

1235

948827

1236

1237

949044

    pub fn draw_layer(

1238

        &mut self,

1239

        layer: &Layer,

1240

        acquired_nodes: &mut AcquiredNodes<'_>,

1241

        clipping: bool,

1242

        viewport: &Viewport,

1243

    ) -> Result<BoundingBox, InternalRenderingError> {

1244

949044

        match &layer.kind {

1245

1896044

            LayerKind::Shape(shape) => self.draw_shape(

1246

948022

                shape,

1247

                &layer.stacking_ctx,

1248

                acquired_nodes,

1249

                clipping,

1250

                viewport,

1251

),

1252

1828

            LayerKind::Text(text) => self.draw_text(

1253

914

                text,

1254

                &layer.stacking_ctx,

1255

                acquired_nodes,

1256

                clipping,

1257

                viewport,

1258

),

1259

216

            LayerKind::Image(image) => self.draw_image(

1260

108

                image,

1261

                &layer.stacking_ctx,

1262

                acquired_nodes,

1263

                clipping,

1264

                viewport,

1265

),

1266

1267

949044

1268

1269

947719

    fn draw_shape(

1270

        &mut self,

1271

        shape: &Shape,

1272

        stacking_ctx: &StackingContext,

1273

        acquired_nodes: &mut AcquiredNodes<'_>,

1274

        clipping: bool,

1275

        viewport: &Viewport,

1276

    ) -> Result<BoundingBox, InternalRenderingError> {

1277

947719

        if shape.extents.is_none() {

1278

18

            return Ok(self.empty_bbox());

1279

1280

1281

947701

        self.with_discrete_layer(

1282

            stacking_ctx,

1283

            acquired_nodes,

1284

            viewport,

1285

947701

            clipping,

1286

1910332

            &mut |an, dc| {

1287

962631

                let cr = dc.cr.clone();

1288

1289

962631

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

1290

                let mut path_helper =

1291

948721

                    PathHelper::new(&cr, transform, &shape.path, shape.stroke.line_cap);

1292

1293

948289

                if clipping {

1294

39

                    if shape.is_visible {

1295

38

                        cr.set_fill_rule(cairo::FillRule::from(shape.clip_rule));

1296

38

                        path_helper.set()?;

1297

1298

39

                    return Ok(dc.empty_bbox());

1299

1300

1301

948250

                cr.set_antialias(cairo::Antialias::from(shape.shape_rendering));

1302

1303

948799

                setup_cr_for_stroke(&cr, &shape.stroke);

1304

1305

947805

                cr.set_fill_rule(cairo::FillRule::from(shape.fill_rule));

1306

1307

948359

                path_helper.set()?;

1308

948132

                let bbox = compute_stroke_and_fill_box(

1309

                    &cr,

1310

948562

                    &shape.stroke,

1311

948562

                    &shape.stroke_paint,

1312

948562

                    &dc.initial_viewport,

1313

)?;

1314

1315

948255

                if shape.is_visible {

1316

3793626

                    for &target in &shape.paint_order.targets {

1317

                        // fill and stroke operations will preserve the path.

1318

                        // markers operation will clear the path.

1319

2844832

                        match target {

1320

                            PaintTarget::Fill => {

1321

948039

                                path_helper.set()?;

1322

948010

                                dc.fill(&cr, an, &shape.fill_paint)?;

1323

1324

1325

                            PaintTarget::Stroke => {

1326

948270

                                path_helper.set()?;

1327

948241

                                let backup_matrix = if shape.stroke.non_scaling {

1328

1

                                    let matrix = cr.matrix();

1329

1

                                    cr.set_matrix(

1330

1

                                        ValidTransform::try_from(dc.initial_viewport.transform)?

1331

                                            .into(),

1332

);

1333

1

                                    Some(matrix)

1334

                                } else {

1335

948239

                                    None

1336

};

1337

1910871

                                dc.stroke(&cr, an, &shape.stroke_paint)?;

1338

948463

                                if let Some(matrix) = backup_matrix {

1339

1

                                    cr.set_matrix(matrix);

1340

1341

1342

1343

948703

                            PaintTarget::Markers => {

1344

948523

                                path_helper.unset();

1345

948490

                                marker::render_markers_for_shape(

1346

949010

                                    shape, viewport, dc, an, clipping,

1347

)?;

1348

1349

1350

1351

1352

1353

953279

                path_helper.unset();

1354

948608

                Ok(bbox)

1355

948647

},

1356

1357

947719

1358

1359

108

    fn paint_surface(

1360

        &mut self,

1361

        surface: &SharedImageSurface,

1362

        width: f64,

1363

        height: f64,

1364

        image_rendering: ImageRendering,

1365

    ) -> Result<(), cairo::Error> {

1366

108

        let cr = self.cr.clone();

1367

1368

        // We need to set extend appropriately, so can't use cr.set_source_surface().

1369

//

1370

        // If extend is left at its default value (None), then bilinear scaling uses

1371

        // transparency outside of the image producing incorrect results.

1372

        // For example, in svg1.1/filters-blend-01-b.svgthere's a completely

1373

        // opaque 100×1 image of a gradient scaled to 100×98 which ends up

1374

        // transparent almost everywhere without this fix (which it shouldn't).

1375

108

        let ptn = surface.to_cairo_pattern();

1376

108

        ptn.set_extend(cairo::Extend::Pad);

1377

1378

108

        let interpolation = Interpolation::from(image_rendering);

1379

1380

108

        ptn.set_filter(cairo::Filter::from(interpolation));

1381

216

        cr.set_source(&ptn)?;

1382

1383

        // Clip is needed due to extend being set to pad.

1384

108

        clip_to_rectangle(&cr, &Rect::from_size(width, height));

1385

1386

108

        cr.paint()

1387

108

1388

1389

108

    fn draw_image(

1390

        &mut self,

1391

        image: &Image,

1392

        stacking_ctx: &StackingContext,

1393

        acquired_nodes: &mut AcquiredNodes<'_>,

1394

        clipping: bool,

1395

        viewport: &Viewport,

1396

    ) -> Result<BoundingBox, InternalRenderingError> {

1397

108

        let image_width = image.surface.width();

1398

108

        let image_height = image.surface.height();

1399

108

        if clipping || image.rect.is_empty() || image_width == 0 || image_height == 0 {

1400

            return Ok(self.empty_bbox());

1401

1402

1403

108

        let image_width = f64::from(image_width);

1404

108

        let image_height = f64::from(image_height);

1405

108

        let vbox = ViewBox::from(Rect::from_size(image_width, image_height));

1406

1407

216

        let clip_mode = if !(image.overflow == Overflow::Auto

1408

108

            || image.overflow == Overflow::Visible)

1409

108

            && image.aspect.is_slice()

1410

1411

12

            ClipMode::ClipToViewport

1412

        } else {

1413

96

            ClipMode::NoClip

1414

};

1415

1416

        // The bounding box for <image> is decided by the values of the image's x, y, w, h

1417

        // and not by the final computed image bounds.

1418

108

        let bounds = self.empty_bbox().with_rect(image.rect);

1419

1420

108

        if image.is_visible {

1421

108

            self.with_discrete_layer(

1422

                stacking_ctx,

1423

                acquired_nodes,

1424

                viewport, // FIXME: should this be the push_new_viewport below?

1425

                clipping,

1426

216

                &mut |_an, dc| {

1427

216

                    with_saved_cr(&dc.cr.clone(), || {

1428

216

                        if let Some(_params) = dc.push_new_viewport(

1429

108

                            viewport,

1430

108

                            Some(vbox),

1431

108

                            image.rect,

1432

108

                            image.aspect,

1433

108

                            clip_mode,

1434

) {

1435

216

                            dc.paint_surface(

1436

108

                                &image.surface,

1437

108

                                image_width,

1438

108

                                image_height,

1439

108

                                image.image_rendering,

1440

)?;

1441

1442

1443

108

                        Ok(bounds)

1444

108

})

1445

108

},

1446

1447

        } else {

1448

            Ok(bounds)

1449

1450

108

1451

1452

1037

    fn draw_text_span(

1453

        &mut self,

1454

        span: &TextSpan,

1455

        acquired_nodes: &mut AcquiredNodes<'_>,

1456

        clipping: bool,

1457

    ) -> Result<BoundingBox, InternalRenderingError> {

1458

1037

        let path = pango_layout_to_path(span.x, span.y, &span.layout, span.gravity)?;

1459

1037

        if path.is_empty() {

1460

            // Empty strings, or only-whitespace text, get turned into empty paths.

1461

            // In that case, we really want to return "no bounds" rather than an

1462

            // empty rectangle.

1463

59

            return Ok(self.empty_bbox());

1464

1465

1466

        // #851 - We can't just render all text as paths for PDF; it

1467

        // needs the actual text content so text is selectable by PDF

1468

        // viewers.

1469

978

        let can_use_text_as_path = self.cr.target().type_() != cairo::SurfaceType::Pdf;

1470

1471

1956

        with_saved_cr(&self.cr.clone(), || {

1472

1956

            self.cr

1473

978

                .set_antialias(cairo::Antialias::from(span.text_rendering));

1474

1475

978

            setup_cr_for_stroke(&self.cr, &span.stroke);

1476

1477

978

            if clipping {

1478

1

                path.to_cairo(&self.cr, false)?;

1479

1

                return Ok(self.empty_bbox());

1480

1481

1482

977

            path.to_cairo(&self.cr, false)?;

1483

977

            let bbox = compute_stroke_and_fill_box(

1484

977

                &self.cr,

1485

977

                &span.stroke,

1486

977

                &span.stroke_paint,

1487

977

                &self.initial_viewport,

1488

)?;

1489

977

            self.cr.new_path();

1490

1491

977

            if span.is_visible {

1492

967

                if let Some(ref link_target) = span.link_target {

1493

4

                    self.link_tag_begin(link_target);

1494

1495

1496

3868

                for &target in &span.paint_order.targets {

1497

2901

                    match target {

1498

                        PaintTarget::Fill => {

1499

                            let had_paint_server =

1500

966

                                self.set_paint_source(&span.fill_paint, acquired_nodes)?;

1501

1502

966

                            if had_paint_server {

1503

964

                                if can_use_text_as_path {

1504

960

                                    path.to_cairo(&self.cr, false)?;

1505

960

                                    self.cr.fill()?;

1506

960

                                    self.cr.new_path();

1507

                                } else {

1508

4

                                    self.cr.move_to(span.x, span.y);

1509

1510

4

                                    let matrix = self.cr.matrix();

1511

1512

4

                                    let rotation_from_gravity = span.gravity.to_rotation();

1513

4

                                    if !rotation_from_gravity.approx_eq_cairo(0.0) {

1514

                                        self.cr.rotate(-rotation_from_gravity);

1515

1516

1517

4

                                    pangocairo::functions::update_layout(&self.cr, &span.layout);

1518

4

                                    pangocairo::functions::show_layout(&self.cr, &span.layout);

1519

1520

4

                                    self.cr.set_matrix(matrix);

1521

1522

1523

1524

1525

                        PaintTarget::Stroke => {

1526

                            let had_paint_server =

1527

967

                                self.set_paint_source(&span.stroke_paint, acquired_nodes)?;

1528

1529

967

                            if had_paint_server {

1530

35

                                path.to_cairo(&self.cr, false)?;

1531

35

                                self.cr.stroke()?;

1532

35

                                self.cr.new_path();

1533

1534

1535

1536

                        PaintTarget::Markers => {}

1537

1538

1539

1540

967

                if span.link_target.is_some() {

1541

4

                    self.link_tag_end();

1542

1543

1544

1545

977

            Ok(bbox)

1546

978

})

1547

1037

1548

1549

914

    fn draw_text(

1550

        &mut self,

1551

        text: &Text,

1552

        stacking_ctx: &StackingContext,

1553

        acquired_nodes: &mut AcquiredNodes<'_>,

1554

        clipping: bool,

1555

        viewport: &Viewport,

1556

    ) -> Result<BoundingBox, InternalRenderingError> {

1557

914

        self.with_discrete_layer(

1558

            stacking_ctx,

1559

            acquired_nodes,

1560

            viewport,

1561

914

            clipping,

1562

1828

            &mut |an, dc| {

1563

914

                let mut bbox = dc.empty_bbox();

1564

1565

1951

                for span in &text.spans {

1566

1037

                    let span_bbox = dc.draw_text_span(span, an, clipping)?;

1567

1037

                    bbox.insert(&span_bbox);

1568

1569

1570

914

                Ok(bbox)

1571

914

},

1572

1573

914

1574

1575

10

    pub fn get_snapshot(

1576

        &self,

1577

        width: i32,

1578

        height: i32,

1579

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1580

        // TODO: as far as I can tell this should not render elements past the last (topmost) one

1581

        // with enable-background: new (because technically we shouldn't have been caching them).

1582

        // Right now there are no enable-background checks whatsoever.

1583

//

1584

        // Addendum: SVG 2 has deprecated the enable-background property, and replaced it with an

1585

        // "isolation" property from the CSS Compositing and Blending spec.

1586

//

1587

        // Deprecation:

1588

        //   https://www.w3.org/TR/filter-effects-1/#AccessBackgroundImage

1589

//

1590

        // BackgroundImage, BackgroundAlpha in the "in" attribute of filter primitives:

1591

        //   https://www.w3.org/TR/filter-effects-1/#attr-valuedef-in-backgroundimage

1592

//

1593

        // CSS Compositing and Blending, "isolation" property:

1594

        //   https://www.w3.org/TR/compositing-1/#isolation

1595

10

        let mut surface = ExclusiveImageSurface::new(width, height, SurfaceType::SRgb)?;

1596

1597

20

        surface.draw(&mut |cr| {

1598

            // TODO: apparently DrawingCtx.cr_stack is just a way to store pairs of

1599

            // (surface, transform).  Can we turn it into a DrawingCtx.surface_stack

1600

            // instead?  See what CSS isolation would like to call that; are the pairs just

1601

            // stacking contexts instead, or the result of rendering stacking contexts?

1602

22

            for (depth, draw) in self.cr_stack.borrow().iter().enumerate() {

1603

12

                let affines = CompositingAffines::new(

1604

12

                    Transform::from(draw.matrix()),

1605

12

                    self.initial_viewport.transform,

1606

                    depth,

1607

);

1608

1609

12

                cr.set_matrix(ValidTransform::try_from(affines.for_snapshot)?.into());

1610

12

                cr.set_source_surface(&draw.target(), 0.0, 0.0)?;

1611

22

                cr.paint()?;

1612

1613

1614

10

            Ok(())

1615

10

        })?;

1616

1617

10

        Ok(surface.share()?)

1618

10

1619

1620

25

    pub fn draw_node_to_surface(

1621

        &mut self,

1622

        node: &Node,

1623

        acquired_nodes: &mut AcquiredNodes<'_>,

1624

        cascaded: &CascadedValues<'_>,

1625

        affine: Transform,

1626

        width: i32,

1627

        height: i32,

1628

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1629

25

        let surface = cairo::ImageSurface::create(cairo::Format::ARgb32, width, height)?;

1630

1631

25

        let save_cr = self.cr.clone();

1632

1633

1634

25

            let cr = cairo::Context::new(&surface)?;

1635

50

            cr.set_matrix(ValidTransform::try_from(affine)?.into());

1636

1637

25

            self.cr = cr;

1638

25

            let viewport = Viewport {

1639

25

                dpi: self.dpi,

1640

                transform: affine,

1641

25

                vbox: ViewBox::from(Rect::from_size(f64::from(width), f64::from(height))),

1642

};

1643

1644

25

            let _ = self.draw_node_from_stack(node, acquired_nodes, cascaded, &viewport, false)?;

1645

25

1646

1647

25

        self.cr = save_cr;

1648

1649

25

        Ok(SharedImageSurface::wrap(surface, SurfaceType::SRgb)?)

1650

25

1651

1652

1460358

    pub fn draw_node_from_stack(

1653

        &mut self,

1654

        node: &Node,

1655

        acquired_nodes: &mut AcquiredNodes<'_>,

1656

        cascaded: &CascadedValues<'_>,

1657

        viewport: &Viewport,

1658

        clipping: bool,

1659

    ) -> Result<BoundingBox, InternalRenderingError> {

1660

1460358

        let stack_top = self.drawsub_stack.pop();

1661

1662

1460358

        let draw = if let Some(ref top) = stack_top {

1663

3116

            top == node

1664

        } else {

1665

1457242

            true

1666

};

1667

1668

1460555

        let res = if draw {

1669

1458465

            node.draw(acquired_nodes, cascaded, viewport, self, clipping)

1670

        } else {

1671

1045

            Ok(self.empty_bbox())

1672

};

1673

1674

1458662

        if let Some(top) = stack_top {

1675

2270

            self.drawsub_stack.push(top);

1676

1677

1678

1458662

res

1679

1458662

1680

1681

500185

    pub fn draw_from_use_node(

1682

        &mut self,

1683

        node: &Node,

1684

        acquired_nodes: &mut AcquiredNodes<'_>,

1685

        values: &ComputedValues,

1686

        use_rect: Rect,

1687

        link: &NodeId,

1688

        clipping: bool,

1689

        viewport: &Viewport,

1690

        fill_paint: Rc<PaintSource>,

1691

        stroke_paint: Rc<PaintSource>,

1692

    ) -> Result<BoundingBox, InternalRenderingError> {

1693

        // <use> is an element that is used directly, unlike

1694

        // <pattern>, which is used through a fill="url(#...)"

1695

        // reference.  However, <use> will always reference another

1696

        // element, potentially itself or an ancestor of itself (or

1697

        // another <use> which references the first one, etc.).  So,

1698

        // we acquire the <use> element itself so that circular

1699

        // references can be caught.

1700

500185

        let _self_acquired = match acquired_nodes.acquire_ref(node) {

1701

500161

            Ok(n) => n,

1702

1703

            Err(AcquireError::CircularReference(_)) => {

1704

4

                rsvg_log!(self.session, "circular reference in element {}", node);

1705

4

                return Ok(self.empty_bbox());

1706

1707

1708

            _ => unreachable!(),

1709

500165

};

1710

1711

500161

        let acquired = match acquired_nodes.acquire(link) {

1712

500178

            Ok(acquired) => acquired,

1713

1714

            Err(AcquireError::CircularReference(node)) => {

1715

                rsvg_log!(self.session, "circular reference in element {}", node);

1716

                return Ok(self.empty_bbox());

1717

1718

1719

            Err(AcquireError::MaxReferencesExceeded) => {

1720

1

                return Err(InternalRenderingError::LimitExceeded(

1721

1

                    ImplementationLimit::TooManyReferencedElements,

1722

));

1723

1724

1725

            Err(AcquireError::InvalidLinkType(_)) => unreachable!(),

1726

1727

4

            Err(AcquireError::LinkNotFound(node_id)) => {

1728

4

                rsvg_log!(

1729

4

                    self.session,

1730

                    "element {} references nonexistent \"{}\"",

1731

                    node,

1732

                    node_id

1733

);

1734

4

                return Ok(self.empty_bbox());

1735

4

1736

5

};

1737

1738

        // width or height set to 0 disables rendering of the element

1739

        // https://www.w3.org/TR/SVG/struct.html#UseElementWidthAttribute

1740

500178

        if use_rect.is_empty() {

1741

            return Ok(self.empty_bbox());

1742

1743

1744

500156

        let child = acquired.get();

1745

1746

500156

        if clipping && !element_can_be_used_inside_use_inside_clip_path(&child.borrow_element()) {

1747

1

            return Ok(self.empty_bbox());

1748

1749

1750

500155

        let orig_transform = self.get_transform();

1751

1752

1000310

        self.cr

1753

1000340

            .transform(ValidTransform::try_from(values.transform())?.into());

1754

1755

500155

        let use_element = node.borrow_element();

1756

1757

500155

        let defines_a_viewport = if is_element_of_type!(child, Symbol) {

1758

9

            let symbol = borrow_element_as!(child, Symbol);

1759

9

            Some((symbol.get_viewbox(), symbol.get_preserve_aspect_ratio()))

1760

500155

        } else if is_element_of_type!(child, Svg) {

1761

1

            let svg = borrow_element_as!(child, Svg);

1762

1

            Some((svg.get_viewbox(), svg.get_preserve_aspect_ratio()))

1763

1

        } else {

1764

500145

            None

1765

};

1766

1767

500155

        let res = if let Some((viewbox, preserve_aspect_ratio)) = defines_a_viewport {

1768

            // <symbol> and <svg> define a viewport, as described in the specification:

1769

            // https://www.w3.org/TR/SVG2/struct.html#UseElement

1770

            // https://gitlab.gnome.org/GNOME/librsvg/-/issues/875#note_1482705

1771

1772

10

            let elt = child.borrow_element();

1773

1774

10

            let child_values = elt.get_computed_values();

1775

1776

            // FIXME: do we need to look at preserveAspectRatio.slice, like in draw_image()?

1777

10

            let clip_mode = if !child_values.is_overflow() {

1778

5

                ClipMode::ClipToViewport

1779

            } else {

1780

5

                ClipMode::NoClip

1781

};

1782

1783

10

            let stacking_ctx = StackingContext::new(

1784

10

                self.session(),

1785

                acquired_nodes,

1786

10

                &use_element,

1787

10

                Transform::identity(),

1788

10

                None,

1789

                values,

1790

);

1791

1792

10

            self.with_discrete_layer(

1793

                &stacking_ctx,

1794

                acquired_nodes,

1795

                viewport, // FIXME: should this be the child_viewport from below?

1796

10

                clipping,

1797

20

                &mut |an, dc| {

1798

20

                    if let Some(child_viewport) = dc.push_new_viewport(

1799

10

                        viewport,

1800

10

                        viewbox,

1801

10

                        use_rect,

1802

10

                        preserve_aspect_ratio,

1803

10

                        clip_mode,

1804

) {

1805

20

                        child.draw_children(

1806

an,

1807

10

                            &CascadedValues::new_from_values(

1808

10

                                child,

1809

10

                                values,

1810

10

                                Some(fill_paint.clone()),

1811

10

                                Some(stroke_paint.clone()),

1812

10

),

1813

                            &child_viewport,

1814

dc,

1815

10

                            clipping,

1816

1817

10

                    } else {

1818

                        Ok(dc.empty_bbox())

1819

1820

10

},

1821

10

1822

10

        } else {

1823

            // otherwise the referenced node is not a <symbol>; process it generically

1824

1825

500145

            let stacking_ctx = StackingContext::new(

1826

500145

                self.session(),

1827

                acquired_nodes,

1828

500145

                &use_element,

1829

500145

                Transform::new_translate(use_rect.x0, use_rect.y0),

1830

500145

                None,

1831

                values,

1832

);

1833

1834

500145

            self.with_discrete_layer(

1835

                &stacking_ctx,

1836

                acquired_nodes,

1837

                viewport,

1838

500145

                clipping,

1839

1000290

                &mut |an, dc| {

1840

1000290

                    child.draw(

1841

an,

1842

500145

                        &CascadedValues::new_from_values(

1843

500145

                            child,

1844

500145

                            values,

1845

500145

                            Some(fill_paint.clone()),

1846

500145

                            Some(stroke_paint.clone()),

1847

500145

),

1848

500145

                        viewport,

1849

dc,

1850

500145

                        clipping,

1851

1852

500145

},

1853

500165

1854

500145

};

1855

1856

500155

        self.cr.set_matrix(orig_transform.into());

1857

1858

1000293

        if let Ok(bbox) = res {

1859

500138

            let mut res_bbox = BoundingBox::new().with_transform(*orig_transform);

1860

500138

            res_bbox.insert(&bbox);

1861

500138

            Ok(res_bbox)

1862

        } else {

1863

17

res

1864

1865

500164

1866

1867

    /// Extracts the font options for the current state of the DrawingCtx.

1868

///

1869

    /// You can use the font options later with create_pango_context().

1870

914

    pub fn get_font_options(&self) -> FontOptions {

1871

914

        let mut options = cairo::FontOptions::new().unwrap();

1872

914

        if self.testing {

1873

869

            options.set_antialias(cairo::Antialias::Gray);

1874

1875

1876

914

        options.set_hint_style(cairo::HintStyle::None);

1877

914

        options.set_hint_metrics(cairo::HintMetrics::Off);

1878

1879

914

        FontOptions { options }

1880

914

1881

1882

1883

impl From<ImageRendering> for Interpolation {

1884

174

    fn from(r: ImageRendering) -> Interpolation {

1885

174

        match r {

1886

            ImageRendering::Pixelated

1887

            | ImageRendering::CrispEdges

1888

1

            | ImageRendering::OptimizeSpeed => Interpolation::Nearest,

1889

1890

            ImageRendering::Smooth

1891

            | ImageRendering::OptimizeQuality

1892

            | ImageRendering::HighQuality

1893

173

            | ImageRendering::Auto => Interpolation::Smooth,

1894

1895

174

1896

1897

1898

/// Create a Pango context with a particular configuration.

1899

1039

pub fn create_pango_context(font_options: &FontOptions, transform: &Transform) -> pango::Context {

1900

1039

    let font_map = pangocairo::FontMap::default();

1901

1039

    let context = font_map.create_context();

1902

1903

1039

    context.set_round_glyph_positions(false);

1904

1905

1039

    let pango_matrix = PangoMatrix {

1906

1039

        xx: transform.xx,

1907

1039

        xy: transform.xy,

1908

1039

        yx: transform.yx,

1909

1039

        yy: transform.yy,

1910

1039

        x0: transform.x0,

1911

1039

        y0: transform.y0,

1912

};

1913

1914

1039

    let pango_matrix_ptr: *const PangoMatrix = &pango_matrix;

1915

1916

1039

    let matrix = unsafe { pango::Matrix::from_glib_none(pango_matrix_ptr) };

1917

1039

    context.set_matrix(Some(&matrix));

1918

1919

1039

    pangocairo::functions::context_set_font_options(&context, Some(&font_options.options));

1920

1921

    // Pango says this about pango_cairo_context_set_resolution():

1922

//

1923

    //     Sets the resolution for the context. This is a scale factor between

1924

    //     points specified in a #PangoFontDescription and Cairo units. The

1925

    //     default value is 96, meaning that a 10 point font will be 13

1926

    //     units high. (10 * 96. / 72. = 13.3).

1927

//

1928

    // I.e. Pango font sizes in a PangoFontDescription are in *points*, not pixels.

1929

    // However, we are normalizing everything to userspace units, which amount to

1930

    // pixels.  So, we will use 72.0 here to make Pango not apply any further scaling

1931

    // to the size values we give it.

1932

//

1933

    // An alternative would be to divide our font sizes by (dpi_y / 72) to effectively

1934

    // cancel out Pango's scaling, but it's probably better to deal with Pango-isms

1935

    // right here, instead of spreading them out through our Length normalization

1936

    // code.

1937

1039

    pangocairo::functions::context_set_resolution(&context, 72.0);

1938

1939

1039

    context

1940

1039

1941

1942

949718

pub fn set_source_color_on_cairo(cr: &cairo::Context, color: &cssparser::Color) {

1943

949718

    let rgba = color_to_rgba(color);

1944

1945

949718

    cr.set_source_rgba(

1946

949718

        f64::from(rgba.red.unwrap_or(0)) / 255.0,

1947

949718

        f64::from(rgba.green.unwrap_or(0)) / 255.0,

1948

949718

        f64::from(rgba.blue.unwrap_or(0)) / 255.0,

1949

949718

        f64::from(rgba.alpha.unwrap_or(0.0)),

1950

);

1951

949718

1952

1953

/// Converts a Pango layout to a Cairo path on the specified cr starting at (x, y).

1954

/// Does not clear the current path first.

1955

1037

fn pango_layout_to_cairo(

1956

    x: f64,

1957

    y: f64,

1958

    layout: &pango::Layout,

1959

    gravity: pango::Gravity,

1960

    cr: &cairo::Context,

1961

) {

1962

1037

    let rotation_from_gravity = gravity.to_rotation();

1963

1037

    let rotation = if !rotation_from_gravity.approx_eq_cairo(0.0) {

1964

        Some(-rotation_from_gravity)

1965

    } else {

1966

1037

        None

1967

};

1968

1969

1037

    cr.move_to(x, y);

1970

1971

1037

    let matrix = cr.matrix();

1972

1037

    if let Some(rot) = rotation {

1973

        cr.rotate(rot);

1974

1975

1976

1037

    pangocairo::functions::update_layout(cr, layout);

1977

1037

    pangocairo::functions::layout_path(cr, layout);

1978

1037

    cr.set_matrix(matrix);

1979

1037

1980

1981

/// Converts a Pango layout to a Path starting at (x, y).

1982

1037

pub fn pango_layout_to_path(

1983

    x: f64,

1984

    y: f64,

1985

    layout: &pango::Layout,

1986

    gravity: pango::Gravity,

1987

) -> Result<Path, InternalRenderingError> {

1988

1037

    let surface = cairo::RecordingSurface::create(cairo::Content::ColorAlpha, None)?;

1989

1037

    let cr = cairo::Context::new(&surface)?;

1990

1991

1037

    pango_layout_to_cairo(x, y, layout, gravity, &cr);

1992

1993

1037

    let cairo_path = cr.copy_path()?;

1994

1037

    Ok(Path::from_cairo(cairo_path))

1995

1037

1996

1997

// https://www.w3.org/TR/css-masking-1/#ClipPathElement

1998

43

fn element_can_be_used_inside_clip_path(element: &Element) -> bool {

1999

    use ElementData::*;

2000

2001

43

    matches!(

2002

43

        element.element_data,

2003

        Circle(_)

2004

            | Ellipse(_)

2005

            | Line(_)

2006

            | Path(_)

2007

            | Polygon(_)

2008

            | Polyline(_)

2009

            | Rect(_)

2010

            | Text(_)

2011

            | Use(_)

2012

2013

43

2014

2015

// https://www.w3.org/TR/css-masking-1/#ClipPathElement

2016

1

fn element_can_be_used_inside_use_inside_clip_path(element: &Element) -> bool {

2017

    use ElementData::*;

2018

2019

1

    matches!(

2020

1

        element.element_data,

2021

        Circle(_) | Ellipse(_) | Line(_) | Path(_) | Polygon(_) | Polyline(_) | Rect(_) | Text(_)

2022

2023

1

2024

2025

#[derive(Debug)]

2026

struct CompositingAffines {

2027

    pub outside_temporary_surface: Transform,

2028

    #[allow(unused)]

2029

    pub initial: Transform,

2030

    pub for_temporary_surface: Transform,

2031

    pub compositing: Transform,

2032

    pub for_snapshot: Transform,

2033

2034

2035

impl CompositingAffines {

2036

1120

    fn new(current: Transform, initial: Transform, cr_stack_depth: usize) -> CompositingAffines {

2037

1120

        let is_topmost_temporary_surface = cr_stack_depth == 0;

2038

2039

1120

        let initial_inverse = initial.invert().unwrap();

2040

2041

1120

        let outside_temporary_surface = if is_topmost_temporary_surface {

2042

648

            current

2043

        } else {

2044

472

            current.post_transform(&initial_inverse)

2045

};

2046

2047

1120

        let (scale_x, scale_y) = initial.transform_distance(1.0, 1.0);

2048

2049

1120

        let for_temporary_surface = if is_topmost_temporary_surface {

2050

648

            current

2051

                .post_transform(&initial_inverse)

2052

                .post_scale(scale_x, scale_y)

2053

        } else {

2054

472

            current

2055

};

2056

2057

1120

        let compositing = if is_topmost_temporary_surface {

2058

648

            initial.pre_scale(1.0 / scale_x, 1.0 / scale_y)

2059

        } else {

2060

472

            Transform::identity()

2061

};

2062

2063

1120

        let for_snapshot = compositing.invert().unwrap();

2064

2065

1120

        CompositingAffines {

2066

1120

            outside_temporary_surface,

2067

1120

            initial,

2068

1120

            for_temporary_surface,

2069

1120

            compositing,

2070

            for_snapshot,

2071

2072

1120

2073

2074

2075

949077

fn compute_stroke_and_fill_extents(

2076

    cr: &cairo::Context,

2077

    stroke: &Stroke,

2078

    stroke_paint_source: &UserSpacePaintSource,

2079

    initial_viewport: &Viewport,

2080

) -> Result<PathExtents, InternalRenderingError> {

2081

    // Dropping the precision of cairo's bezier subdivision, yielding 2x

2082

    // _rendering_ time speedups, are these rather expensive operations

2083

    // really needed here? */

2084

949077

    let backup_tolerance = cr.tolerance();

2085

949077

    cr.set_tolerance(1.0);

2086

2087

    // Bounding box for fill

2088

//

2089

    // Unlike the case for stroke, for fills we always compute the bounding box.

2090

    // In GNOME we have SVGs for symbolic icons where each icon has a bounding

2091

    // rectangle with no fill and no stroke, and inside it there are the actual

2092

    // paths for the icon's shape.  We need to be able to compute the bounding

2093

    // rectangle's extents, even when it has no fill nor stroke.

2094

2095

949077

    let (x0, y0, x1, y1) = cr.fill_extents()?;

2096

949077

    let fill_extents = if x0 != 0.0 || y0 != 0.0 || x1 != 0.0 || y1 != 0.0 {

2097

504381

        Some(Rect::new(x0, y0, x1, y1))

2098

    } else {

2099

444696

        None

2100

};

2101

2102

    // Bounding box for stroke

2103

//

2104

    // When presented with a line width of 0, Cairo returns a

2105

    // stroke_extents rectangle of (0, 0, 0, 0).  This would cause the

2106

    // bbox to include a lone point at the origin, which is wrong, as a

2107

    // stroke of zero width should not be painted, per

2108

    // https://www.w3.org/TR/SVG2/painting.html#StrokeWidth

2109

//

2110

    // So, see if the stroke width is 0 and just not include the stroke in the

2111

    // bounding box if so.

2112

2113

1897296

    let stroke_extents = if !stroke.width.approx_eq_cairo(0.0)

2114

948219

        && !matches!(stroke_paint_source, UserSpacePaintSource::None)

2115

2116

501181

        let backup_matrix = if stroke.non_scaling {

2117

1

            let matrix = cr.matrix();

2118

949078

            cr.set_matrix(ValidTransform::try_from(initial_viewport.transform)?.into());

2119

1

            Some(matrix)

2120

        } else {

2121

501179

            None

2122

};

2123

501180

        let (x0, y0, x1, y1) = cr.stroke_extents()?;

2124

501180

        if let Some(matrix) = backup_matrix {

2125

1

            cr.set_matrix(matrix);

2126

2127

501180

        Some(Rect::new(x0, y0, x1, y1))

2128

    } else {

2129

447897

        None

2130

};

2131

2132

    // objectBoundingBox

2133

2134

949077

    let (x0, y0, x1, y1) = cr.path_extents()?;

2135

949077

    let path_extents = Some(Rect::new(x0, y0, x1, y1));

2136

2137

    // restore tolerance

2138

2139

949077

    cr.set_tolerance(backup_tolerance);

2140

2141

949077

    Ok(PathExtents {

2142

        path_only: path_extents,

2143

949077

        fill: fill_extents,

2144

949077

        stroke: stroke_extents,

2145

})

2146

949077

2147

2148

949881

fn compute_stroke_and_fill_box(

2149

    cr: &cairo::Context,

2150

    stroke: &Stroke,

2151

    stroke_paint_source: &UserSpacePaintSource,

2152

    initial_viewport: &Viewport,

2153

) -> Result<BoundingBox, InternalRenderingError> {

2154

    let extents =

2155

949881

        compute_stroke_and_fill_extents(cr, stroke, stroke_paint_source, initial_viewport)?;

2156

2157

949881

    let ink_rect = match (extents.fill, extents.stroke) {

2158

444466

        (None, None) => None,

2159

4235

        (Some(f), None) => Some(f),

2160

230

        (None, Some(s)) => Some(s),

2161

500950

        (Some(f), Some(s)) => Some(f.union(&s)),

2162

};

2163

2164

949881

    let mut bbox = BoundingBox::new().with_transform(Transform::from(cr.matrix()));

2165

2166

949881

    if let Some(rect) = extents.path_only {

2167

949774

        bbox = bbox.with_rect(rect);

2168

2169

2170

949881

    if let Some(ink_rect) = ink_rect {

2171

505415

        bbox = bbox.with_ink_rect(ink_rect);

2172

2173

2174

949881

    Ok(bbox)

2175

949881

2176

2177

948969

fn setup_cr_for_stroke(cr: &cairo::Context, stroke: &Stroke) {

2178

948969

    cr.set_line_width(stroke.width);

2179

948969

    cr.set_miter_limit(stroke.miter_limit.0);

2180

948969

    cr.set_line_cap(cairo::LineCap::from(stroke.line_cap));

2181

948969

    cr.set_line_join(cairo::LineJoin::from(stroke.line_join));

2182

2183

948969

    let total_length: f64 = stroke.dashes.iter().sum();

2184

2185

948969

    if total_length > 0.0 {

2186

106

        cr.set_dash(&stroke.dashes, stroke.dash_offset);

2187

    } else {

2188

948863

        cr.set_dash(&[], 0.0);

2189

2190

948969

2191

2192

/// escape quotes and backslashes with backslash

2193

6

fn escape_link_target(value: &str) -> Cow<'_, str> {

2194

    let regex = {

2195

        static REGEX: OnceLock<Regex> = OnceLock::new();

2196

9

        REGEX.get_or_init(|| Regex::new(r"['\\]").unwrap())

2197

};

2198

2199

6

    regex.replace_all(value, |caps: &Captures<'_>| {

2200

        match caps.get(0).unwrap().as_str() {

2201

            "'" => "\\'".to_owned(),

2202

            "\\" => "\\\\".to_owned(),

2203

            _ => unreachable!(),

2204

2205

})

2206

6

2207

2208

400

fn clip_to_rectangle(cr: &cairo::Context, r: &Rect) {

2209

400

    cr.rectangle(r.x0, r.y0, r.width(), r.height());

2210

400

    cr.clip();

2211

400

2212

2213

impl From<SpreadMethod> for cairo::Extend {

2214

163

    fn from(s: SpreadMethod) -> cairo::Extend {

2215

163

        match s {

2216

157

            SpreadMethod::Pad => cairo::Extend::Pad,

2217

3

            SpreadMethod::Reflect => cairo::Extend::Reflect,

2218

3

            SpreadMethod::Repeat => cairo::Extend::Repeat,

2219

2220

163

2221

2222

2223

impl From<StrokeLinejoin> for cairo::LineJoin {

2224

949666

    fn from(j: StrokeLinejoin) -> cairo::LineJoin {

2225

949666

        match j {

2226

949533

            StrokeLinejoin::Miter => cairo::LineJoin::Miter,

2227

131

            StrokeLinejoin::Round => cairo::LineJoin::Round,

2228

2

            StrokeLinejoin::Bevel => cairo::LineJoin::Bevel,

2229

2230

949666

2231

2232

2233

impl From<StrokeLinecap> for cairo::LineCap {

2234

949176

    fn from(j: StrokeLinecap) -> cairo::LineCap {

2235

949176

        match j {

2236

948986

            StrokeLinecap::Butt => cairo::LineCap::Butt,

2237

158

            StrokeLinecap::Round => cairo::LineCap::Round,

2238

32

            StrokeLinecap::Square => cairo::LineCap::Square,

2239

2240

949176

2241

2242

2243

impl From<MixBlendMode> for cairo::Operator {

2244

681

    fn from(m: MixBlendMode) -> cairo::Operator {

2245

        use cairo::Operator;

2246

2247

681

        match m {

2248

665

            MixBlendMode::Normal => Operator::Over,

2249

1

            MixBlendMode::Multiply => Operator::Multiply,

2250

1

            MixBlendMode::Screen => Operator::Screen,

2251

1

            MixBlendMode::Overlay => Operator::Overlay,

2252

1

            MixBlendMode::Darken => Operator::Darken,

2253

1

            MixBlendMode::Lighten => Operator::Lighten,

2254

1

            MixBlendMode::ColorDodge => Operator::ColorDodge,

2255

1

            MixBlendMode::ColorBurn => Operator::ColorBurn,

2256

1

            MixBlendMode::HardLight => Operator::HardLight,

2257

1

            MixBlendMode::SoftLight => Operator::SoftLight,

2258

2

            MixBlendMode::Difference => Operator::Difference,

2259

1

            MixBlendMode::Exclusion => Operator::Exclusion,

2260

1

            MixBlendMode::Hue => Operator::HslHue,

2261

1

            MixBlendMode::Saturation => Operator::HslSaturation,

2262

1

            MixBlendMode::Color => Operator::HslColor,

2263

1

            MixBlendMode::Luminosity => Operator::HslLuminosity,

2264

2265

681

2266

2267

2268

impl From<ClipRule> for cairo::FillRule {

2269

38

    fn from(c: ClipRule) -> cairo::FillRule {

2270

38

        match c {

2271

37

            ClipRule::NonZero => cairo::FillRule::Winding,

2272

1

            ClipRule::EvenOdd => cairo::FillRule::EvenOdd,

2273

2274

38

2275

2276

2277

impl From<FillRule> for cairo::FillRule {

2278

947778

    fn from(f: FillRule) -> cairo::FillRule {

2279

947778

        match f {

2280

947614

            FillRule::NonZero => cairo::FillRule::Winding,

2281

164

            FillRule::EvenOdd => cairo::FillRule::EvenOdd,

2282

2283

947778

2284

2285

2286

impl From<ShapeRendering> for cairo::Antialias {

2287

948315

    fn from(sr: ShapeRendering) -> cairo::Antialias {

2288

948315

        match sr {

2289

948302

            ShapeRendering::Auto | ShapeRendering::GeometricPrecision => cairo::Antialias::Default,

2290

13

            ShapeRendering::OptimizeSpeed | ShapeRendering::CrispEdges => cairo::Antialias::None,

2291

2292

948315

2293

2294

2295

impl From<TextRendering> for cairo::Antialias {

2296

978

    fn from(tr: TextRendering) -> cairo::Antialias {

2297

978

        match tr {

2298

            TextRendering::Auto

2299

            | TextRendering::OptimizeLegibility

2300

978

            | TextRendering::GeometricPrecision => cairo::Antialias::Default,

2301

            TextRendering::OptimizeSpeed => cairo::Antialias::None,

2302

2303

978

2304

2305

2306

impl From<cairo::Matrix> for Transform {

2307

    #[inline]

2308

10416807

    fn from(m: cairo::Matrix) -> Self {

2309

10416807

        Self::new_unchecked(m.xx(), m.yx(), m.xy(), m.yy(), m.x0(), m.y0())

2310

10416807

2311

2312

2313

impl From<ValidTransform> for cairo::Matrix {

2314

    #[inline]

2315

6063184

    fn from(t: ValidTransform) -> cairo::Matrix {

2316

6063184

        cairo::Matrix::new(t.xx, t.yx, t.xy, t.yy, t.x0, t.y0)

2317

6063184

2318

2319

2320

/// Extents for a path in its current coordinate system.

2321

///

2322

/// Normally you'll want to convert this to a BoundingBox, which has knowledge about just

2323

/// what that coordinate system is.

2324

pub struct PathExtents {

2325

    /// Extents of the "plain", unstroked path, or `None` if the path is empty.

2326

    pub path_only: Option<Rect>,

2327

2328

    /// Extents of just the fill, or `None` if the path is empty.

2329

    pub fill: Option<Rect>,

2330

2331

    /// Extents for the stroked path, or `None` if the path is empty or zero-width.

2332

    pub stroke: Option<Rect>,

2333

2334

2335

impl Path {

2336

1898187

    pub fn to_cairo(

2337

        &self,

2338

        cr: &cairo::Context,

2339

        is_square_linecap: bool,

2340

    ) -> Result<(), InternalRenderingError> {

2341

1898187

        assert!(!self.is_empty());

2342

2343

3832606

        for subpath in self.iter_subpath() {

2344

            // If a subpath is empty and the linecap is a square, then draw a square centered on

2345

            // the origin of the subpath. See #165.

2346

1934419

            if is_square_linecap {

2347

34

                let (x, y) = subpath.origin();

2348

34

                if subpath.is_zero_length() {

2349

1898187

                    let stroke_size = 0.002;

2350

2351

1

                    cr.move_to(x - stroke_size / 2., y);

2352

1

                    cr.line_to(x + stroke_size / 2., y);

2353

2354

2355

2356

13838215

            for cmd in subpath.iter_commands() {

2357

11903796

                cmd.to_cairo(cr);

2358

2359

2360

2361

        // We check the cr's status right after feeding it a new path for a few reasons:

2362

//

2363

        // * Any of the individual path commands may cause the cr to enter an error state, for

2364

        //   example, if they come with coordinates outside of Cairo's supported range.

2365

//

2366

        // * The *next* call to the cr will probably be something that actually checks the status

2367

        //   (i.e. in cairo-rs), and we don't want to panic there.

2368

2369

1898187

        cr.status().map_err(|e| e.into())

2370

1898187

2371

2372

    /// Converts a `cairo::Path` to a librsvg `Path`.

2373

1038

    fn from_cairo(cairo_path: cairo::Path) -> Path {

2374

1038

        let mut builder = PathBuilder::default();

2375

2376

        // Cairo has the habit of appending a MoveTo to some paths, but we don't want a

2377

        // path for empty text to generate that lone point.  So, strip out paths composed

2378

        // only of MoveTo.

2379

2380

1038

        if !cairo_path_is_only_move_tos(&cairo_path) {

2381

252165

            for segment in cairo_path.iter() {

2382

251189

                match segment {

2383

19591

                    cairo::PathSegment::MoveTo((x, y)) => builder.move_to(x, y),

2384

75945

                    cairo::PathSegment::LineTo((x, y)) => builder.line_to(x, y),

2385

137041

                    cairo::PathSegment::CurveTo((x2, y2), (x3, y3), (x4, y4)) => {

2386

137041

                        builder.curve_to(x2, y2, x3, y3, x4, y4)

2387

2388

18612

                    cairo::PathSegment::ClosePath => builder.close_path(),

2389

2390

2391

2392

2393

1037

        builder.into_path()

2394

1032

2395

2396

2397

1038

fn cairo_path_is_only_move_tos(path: &cairo::Path) -> bool {

2398

1038

    path.iter()

2399

2017

        .all(|seg| matches!(seg, cairo::PathSegment::MoveTo((_, _))))

2400

1038

2401

2402

impl PathCommand {

2403

11909089

    fn to_cairo(&self, cr: &cairo::Context) {

2404

11909089

        match *self {

2405

1937972

            PathCommand::MoveTo(x, y) => cr.move_to(x, y),

2406

7742687

            PathCommand::LineTo(x, y) => cr.line_to(x, y),

2407

290420

            PathCommand::CurveTo(ref curve) => curve.to_cairo(cr),

2408

2588

            PathCommand::Arc(ref arc) => arc.to_cairo(cr),

2409

1935422

            PathCommand::ClosePath => cr.close_path(),

2410

2411

11909089

2412

2413

2414

impl EllipticalArc {

2415

2588

    fn to_cairo(&self, cr: &cairo::Context) {

2416

2588

        match self.center_parameterization() {

2417

            ArcParameterization::CenterParameters {

2418

2588

                center,

2419

2588

                radii,

2420

2588

                theta1,

2421

2588

                delta_theta,

2422

            } => {

2423

2588

                let n_segs = (delta_theta / (PI * 0.5 + 0.001)).abs().ceil() as u32;

2424

2588

                let d_theta = delta_theta / f64::from(n_segs);

2425

2426

2588

                let mut theta = theta1;

2427

6604

                for _ in 0..n_segs {

2428

4016

                    arc_segment(center, radii, self.x_axis_rotation, theta, theta + d_theta)

2429

                        .to_cairo(cr);

2430

4016

                    theta += d_theta;

2431

2432

2433

            ArcParameterization::LineTo => {

2434

                let (x2, y2) = self.to;

2435

                cr.line_to(x2, y2);

2436

2437

            ArcParameterization::Omit => {}

2438

2439

2588

2440

2441

2442

impl CubicBezierCurve {

2443

294431

    fn to_cairo(&self, cr: &cairo::Context) {

2444

294431

        let Self { pt1, pt2, to } = *self;

2445

294431

        cr.curve_to(pt1.0, pt1.1, pt2.0, pt2.1, to.0, to.1);

2446

294431

2447

2448

2449

#[cfg(test)]

2450

mod tests {

2451

    use super::*;

2452

2453

    #[test]

2454

2

    fn rsvg_path_from_cairo_path() {

2455

1

        let surface = cairo::ImageSurface::create(cairo::Format::ARgb32, 10, 10).unwrap();

2456

1

        let cr = cairo::Context::new(&surface).unwrap();

2457

2458

1

        cr.move_to(1.0, 2.0);

2459

1

        cr.line_to(3.0, 4.0);

2460

1

        cr.curve_to(5.0, 6.0, 7.0, 8.0, 9.0, 10.0);

2461

1

        cr.close_path();

2462

2463

1

        let cairo_path = cr.copy_path().unwrap();

2464

1

        let path = Path::from_cairo(cairo_path);

2465

2466

2

        assert_eq!(

2467

1

            path.iter().collect::<Vec<PathCommand>>(),

2468

1

            vec![

2469

1

                PathCommand::MoveTo(1.0, 2.0),

2470

1

                PathCommand::LineTo(3.0, 4.0),

2471

1

                PathCommand::CurveTo(CubicBezierCurve {

2472

1

                    pt1: (5.0, 6.0),

2473

1

                    pt2: (7.0, 8.0),

2474

1

                    to: (9.0, 10.0),

2475

}),

2476

1

                PathCommand::ClosePath,

2477

1

                PathCommand::MoveTo(1.0, 2.0), // cairo inserts a MoveTo after ClosePath

2478

],

2479

);

2480

2

2481