Grcov report - drawing

1

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

2

3

use float_cmp::approx_eq;

4

use gio::prelude::*;

5

use glib::translate::*;

6

use pango::ffi::PangoMatrix;

7

use pango::prelude::FontMapExt;

8

use regex::{Captures, Regex};

9

use std::cell::RefCell;

10

use std::convert::TryFrom;

11

use std::rc::Rc;

12

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

13

14

use crate::accept_language::UserLanguage;

15

use crate::bbox::BoundingBox;

16

use crate::cairo_path::CairoPath;

17

use crate::color::color_to_rgba;

18

use crate::coord_units::CoordUnits;

19

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

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

    self, Filter, Group, Image, Layer, LayerKind, LayoutViewport, Shape, StackingContext, Stroke,

28

    Text, TextSpan,

29

};

30

use crate::length::*;

31

use crate::limits;

32

use crate::marker;

33

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

34

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

35

use crate::pattern::UserSpacePattern;

36

use crate::properties::{

37

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

38

    PaintTarget, ShapeRendering, StrokeLinecap, StrokeLinejoin, TextRendering,

39

};

40

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

41

use crate::rsvg_log;

42

use crate::session::Session;

43

use crate::surface_utils::shared_surface::{

44

    ExclusiveImageSurface, Interpolation, SharedImageSurface, SurfaceType,

45

};

46

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

47

use crate::unit_interval::UnitInterval;

48

use crate::viewbox::ViewBox;

49

use crate::{borrow_element_as, is_element_of_type};

50

51

/// Opaque font options for a DrawingCtx.

52

///

53

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

54

pub struct FontOptions {

55

    options: cairo::FontOptions,

56

57

58

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

59

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

60

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

61

struct PathHelper<'a> {

62

    cr: &'a cairo::Context,

63

    transform: ValidTransform,

64

    cairo_path: &'a CairoPath,

65

    has_path: Option<bool>,

66

67

68

impl<'a> PathHelper<'a> {

69

948527

    pub fn new(

70

        cr: &'a cairo::Context,

71

        transform: ValidTransform,

72

        cairo_path: &'a CairoPath,

73

    ) -> Self {

74

948527

        PathHelper {

75

cr,

76

            transform,

77

            cairo_path,

78

948527

            has_path: None,

79

80

948527

81

82

2843563

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

83

2843563

        match self.has_path {

84

            Some(false) | None => {

85

949115

                self.has_path = Some(true);

86

949115

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

87

949115

                self.cairo_path.to_cairo_context(self.cr)

88

89

1894448

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

90

91

2843563

92

93

1896157

    pub fn unset(&mut self) {

94

1896151

        match self.has_path {

95

            Some(true) | None => {

96

948834

                self.has_path = Some(false);

97

948834

                self.cr.new_path();

98

99

            Some(false) => {}

100

101

1896157

102

103

104

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

105

105612

#[derive(Clone)]

106

pub struct Viewport {

107

52806

    pub dpi: Dpi,

108

109

    /// Corners of the current coordinate space.

110

52806

    pub vbox: ViewBox,

111

112

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

113

52806

    pub transform: Transform,

114

115

116

impl Viewport {

117

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

118

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

119

168

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

120

168

        Viewport {

121

            dpi,

122

168

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

123

168

            transform: Default::default(),

124

125

168

126

127

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

128

///

129

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

130

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

131

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

132

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

133

///

134

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

135

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

136

    /// system unchanged.

137

501232

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

138

501232

        match units {

139

406

            CoordUnits::ObjectBoundingBox => Viewport {

140

406

                dpi: self.dpi,

141

406

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

142

406

                transform: self.transform,

143

406

},

144

145

500826

            CoordUnits::UserSpaceOnUse => Viewport {

146

500826

                dpi: self.dpi,

147

500826

                vbox: self.vbox,

148

500826

                transform: self.transform,

149

500826

},

150

151

501232

152

153

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

154

193

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

155

193

        Viewport {

156

193

            dpi: self.dpi,

157

193

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

158

193

            transform: self.transform,

159

160

193

161

162

2006501

    pub fn with_composed_transform(&self, transform: Transform) -> Viewport {

163

2006501

        Viewport {

164

2006501

            dpi: self.dpi,

165

2006501

            vbox: self.vbox,

166

2006501

            transform: self.transform.pre_transform(&transform),

167

168

2006501

169

170

171

/// Values that stay constant during rendering with a DrawingCtx.

172

101570

#[derive(Clone)]

173

pub struct RenderingConfiguration {

174

50785

    pub dpi: Dpi,

175

50785

    pub cancellable: Option<gio::Cancellable>,

176

50785

    pub user_language: UserLanguage,

177

50785

    pub svg_nesting: SvgNesting,

178

50785

    pub measuring: bool,

179

50785

    pub testing: bool,

180

181

182

pub struct DrawingCtx {

183

    session: Session,

184

185

    initial_viewport: Viewport,

186

187

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

188

    cr: cairo::Context,

189

190

    drawsub_stack: Vec<Node>,

191

192

    config: RenderingConfiguration,

193

194

    /// Depth of nested layers while drawing.

195

///

196

    /// We use this to set a hard limit on how many nested layers there can be, to avoid

197

    /// malicious SVGs that would cause unbounded stack consumption.

198

    recursion_depth: u16,

199

200

201

pub enum DrawingMode {

202

    LimitToStack { node: Node, root: Node },

203

204

    OnlyNode(Node),

205

206

207

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

208

///

209

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

210

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

211

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

212

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

213

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

214

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

215

50785

#[derive(Copy, Clone)]

216

pub enum SvgNesting {

217

    Standalone,

218

    ReferencedFromImageElement,

219

220

221

/// The toplevel drawing routine.

222

///

223

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

224

1118

pub fn draw_tree(

225

    session: Session,

226

    mode: DrawingMode,

227

    cr: &cairo::Context,

228

    viewport_rect: Rect,

229

    config: RenderingConfiguration,

230

    acquired_nodes: &mut AcquiredNodes<'_>,

231

) -> Result<BoundingBox, InternalRenderingError> {

232

2238

    let (drawsub_stack, node) = match mode {

233

1100

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

234

235

18

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

236

};

237

238

1120

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

239

240

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

241

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

242

1117

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

243

1117

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

244

245

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

246

//

247

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

248

    // determine an initial viewport coordinate system and an

249

    // initial user coordinate system such that the two

250

    // coordinates systems are identical. The origin of both

251

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

252

    // viewport."

253

//

254

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

255

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

256

    // the top/left of the viewport"

257

258

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

259

1119

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

260

261

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

262

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

263

    // element and ignore the error.

264

2236

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

265

1119

    cr.set_matrix(valid_transform.into());

266

267

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

268

1123

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

269

1119

    let initial_viewport = Viewport {

270

1119

        dpi: config.dpi,

271

1119

        vbox: ViewBox::from(viewport_rect),

272

        transform,

273

};

274

275

1119

    let mut draw_ctx = DrawingCtx::new(session, cr, &initial_viewport, config, drawsub_stack);

276

277

1119

    let content_bbox = draw_ctx.draw_node_from_stack(

278

        &node,

279

        acquired_nodes,

280

        &cascaded,

281

        &initial_viewport,

282

        false,

283

6

)?;

284

285

1113

    user_bbox.insert(&content_bbox);

286

287

1113

    if draw_ctx.is_rendering_cancelled() {

288

        Err(InternalRenderingError::Cancelled)

289

    } else {

290

1113

        Ok(user_bbox)

291

292

1119

293

294

2009711

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

2009711

    cr.save()?;

299

2008302

    match f() {

300

2008041

        Ok(o) => {

301

4018769

            cr.restore()?;

302

2008860

            Ok(o)

303

2008860

304

305

335

        Err(e) => Err(e),

306

307

2009195

308

309

impl Drop for DrawingCtx {

310

51904

    fn drop(&mut self) {

311

51904

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

312

51904

313

314

315

const CAIRO_TAG_LINK: &str = "Link";

316

317

impl DrawingCtx {

318

1117

    fn new(

319

        session: Session,

320

        cr: &cairo::Context,

321

        initial_viewport: &Viewport,

322

        config: RenderingConfiguration,

323

        drawsub_stack: Vec<Node>,

324

    ) -> DrawingCtx {

325

1115

        DrawingCtx {

326

1121

            session,

327

1121

            initial_viewport: initial_viewport.clone(),

328

1119

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

329

1115

            cr: cr.clone(),

330

1115

            drawsub_stack,

331

1115

            config,

332

            recursion_depth: 0,

333

334

1115

335

336

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

337

///

338

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

339

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

340

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

341

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

342

50785

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

343

50785

        let cr_stack = self.cr_stack.clone();

344

345

50785

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

346

347

50785

        Box::new(DrawingCtx {

348

50785

            session: self.session.clone(),

349

50785

            initial_viewport: self.initial_viewport.clone(),

350

50785

            cr_stack,

351

50785

cr,

352

50785

            drawsub_stack: self.drawsub_stack.clone(),

353

50785

            config: self.config.clone(),

354

50785

            recursion_depth: self.recursion_depth,

355

})

356

50785

357

358

6911114

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

359

6911114

        &self.session

360

6911114

361

362

    /// Returns the `RenderingOptions` being used for rendering.

363

15

    pub fn rendering_options(&self, svg_nesting: SvgNesting) -> RenderingOptions {

364

15

        RenderingOptions {

365

15

            dpi: self.config.dpi,

366

15

            cancellable: self.config.cancellable.clone(),

367

15

            user_language: self.config.user_language.clone(),

368

            svg_nesting,

369

15

            testing: self.config.testing,

370

371

15

372

373

19

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

374

        &self.config.user_language

375

19

376

377

1762

    pub fn toplevel_viewport(&self) -> Rect {

378

1762

        *self.initial_viewport.vbox

379

1762

380

381

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

382

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

383

///

384

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

385

    /// to remove it.

386

947587

    pub fn get_transform_for_stacking_ctx(

387

        &self,

388

        stacking_ctx: &StackingContext,

389

        clipping: bool,

390

    ) -> Result<ValidTransform, InternalRenderingError> {

391

948009

        if stacking_ctx.should_isolate() && !clipping {

392

422

            let affines = CompositingAffines::new(

393

422

                *self.get_transform(),

394

422

                self.initial_viewport.transform,

395

422

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

396

422

);

397

398

948009

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

399

        } else {

400

947165

            Ok(self.get_transform())

401

402

947587

403

404

1165

    pub fn svg_nesting(&self) -> SvgNesting {

405

1165

        self.config.svg_nesting

406

1165

407

408

1096

    pub fn is_measuring(&self) -> bool {

409

1096

        self.config.measuring

410

1096

411

412

    pub fn is_testing(&self) -> bool {

413

        self.config.testing

414

415

416

9464452

    pub fn get_transform(&self) -> ValidTransform {

417

9464452

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

418

9464452

        ValidTransform::try_from(t)

419

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

420

9464452

421

422

3515286

    pub fn empty_bbox(&self) -> BoundingBox {

423

3515286

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

424

3515286

425

426

746

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

427

746

        let rect = self.toplevel_viewport();

428

429

746

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

430

431

746

        let (width, height) = self

432

            .initial_viewport

433

            .transform

434

            .transform_distance(viewport_width, viewport_height);

435

436

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

437

        // into the temporary surface.

438

746

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

439

746

440

441

363

    pub fn create_surface_for_toplevel_viewport(

442

        &self,

443

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

444

363

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

445

446

363

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

447

363

448

449

384

    fn create_similar_surface_for_toplevel_viewport(

450

        &self,

451

        surface: &cairo::Surface,

452

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

453

384

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

454

455

384

        Ok(cairo::Surface::create_similar(

456

            surface,

457

384

            cairo::Content::ColorAlpha,

458

w,

459

h,

460

)?)

461

384

462

463

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

464

///

465

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

466

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

467

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

468

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

469

1280

    pub fn push_new_viewport(

470

        &self,

471

        current_viewport: &Viewport,

472

        layout_viewport: &LayoutViewport,

473

    ) -> Option<Viewport> {

474

        let LayoutViewport {

475

1280

            geometry,

476

1280

            vbox,

477

1280

            preserve_aspect_ratio,

478

1280

            overflow,

479

        } = *layout_viewport;

480

481

1280

        if !overflow.overflow_allowed() || (vbox.is_some() && preserve_aspect_ratio.is_slice()) {

482

177

            clip_to_rectangle(&self.cr, &geometry);

483

484

485

2560

        preserve_aspect_ratio

486

            .viewport_to_viewbox_transform(vbox, &geometry)

487

2

            .unwrap_or_else(|_e| {

488

2

                match vbox {

489

                    None => unreachable!(

490

                        "viewport_to_viewbox_transform only returns errors when vbox != None"

491

),

492

2

                    Some(v) => {

493

                        rsvg_log!(

494

2

                            self.session,

495

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

496

                            v.x0,

497

                            v.y0,

498

                            v.width(),

499

                            v.height()

500

);

501

502

503

2

                None

504

2

})

505

2560

            .map(|t| {

506

                // FMQ: here

507

1280

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

508

509

1280

                Viewport {

510

1280

                    dpi: self.config.dpi,

511

1280

                    vbox: vbox.unwrap_or(current_viewport.vbox),

512

1280

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

513

514

1280

})

515

1280

516

517

2006120

    fn clip_to_node(

518

        &mut self,

519

        clip_node: &Option<Node>,

520

        acquired_nodes: &mut AcquiredNodes<'_>,

521

        viewport: &Viewport,

522

        bbox: &BoundingBox,

523

    ) -> Result<(), InternalRenderingError> {

524

2006120

        if clip_node.is_none() {

525

2005991

            return Ok(());

526

527

528

129

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

529

129

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

530

531

129

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

532

127

            let cascaded = CascadedValues::new_from_node(node);

533

127

            let values = cascaded.get();

534

535

43

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

536

2006163

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

537

538

42

            let orig_transform = self.get_transform();

539

            // FMQ: here

540

42

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

541

542

168

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

543

126

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

544

126

            }) {

545

42

                child.draw(

546

                    acquired_nodes,

547

42

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

548

                    viewport,

549

                    self,

550

                    true,

551

42

)?;

552

84

553

554

42

            self.cr.clip();

555

556

42

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

557

43

558

559

44

        Ok(())

560

2006036

561

562

61

    fn generate_cairo_mask(

563

        &mut self,

564

        mask_node: &Node,

565

        viewport: &Viewport,

566

        transform: Transform,

567

        bbox: &BoundingBox,

568

        acquired_nodes: &mut AcquiredNodes<'_>,

569

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

570

61

        if bbox.rect.is_none() {

571

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

572

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

573

1

            return Ok(None);

574

575

576

60

        let _mask_acquired = match acquired_nodes.acquire_ref(mask_node) {

577

60

            Ok(n) => n,

578

579

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

580

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

581

                return Ok(None);

582

583

584

            _ => unreachable!(),

585

60

};

586

587

60

        let mask_element = mask_node.borrow_element();

588

        let mask = borrow_element_as!(mask_node, Mask);

589

590

60

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

591

592

60

        let cascaded = CascadedValues::new_from_node(mask_node);

593

60

        let values = cascaded.get();

594

595

60

        let mask_units = mask.get_units();

596

597

        let mask_rect = {

598

60

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

599

60

            mask.get_rect(&params)

600

};

601

602

60

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

603

60

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

604

605

60

        let mask_content_surface = self.create_surface_for_toplevel_viewport()?;

606

607

        // Use a scope because mask_cr needs to release the

608

        // reference to the surface before we access the pixels

609

610

60

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

611

60

            mask_cr.set_matrix(transform_for_mask.into());

612

613

60

            let bbtransform = Transform::new_unchecked(

614

60

                bbox_rect.width(),

615

                0.0,

616

                0.0,

617

60

                bbox_rect.height(),

618

60

                bbox_rect.x0,

619

60

                bbox_rect.y0,

620

);

621

622

60

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

623

10

                bbtransform.transform_rect(&mask_rect)

624

            } else {

625

50

                mask_rect

626

};

627

628

60

            clip_to_rectangle(&mask_cr, &clip_rect);

629

630

60

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

631

5

                if bbox_rect.is_empty() {

632

1

                    return Ok(None);

633

634

65

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

635

636

637

            // FMQ: above - and here, the mask_viewport need the new bbtransform composed too

638

59

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

639

640

59

            let mut mask_draw_ctx = self.nested(mask_cr);

641

642

59

            let stacking_ctx = Box::new(StackingContext::new(

643

59

                self.session(),

644

                acquired_nodes,

645

59

                &mask_element,

646

59

                Transform::identity(),

647

59

                None,

648

                values,

649

));

650

651

59

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

652

653

118

            let res = mask_draw_ctx.with_discrete_layer(

654

59

                &stacking_ctx,

655

                acquired_nodes,

656

                &mask_viewport,

657

59

                None,

658

                false,

659

118

                &mut |an, dc, new_viewport| {

660

59

                    mask_node.draw_children(an, &cascaded, new_viewport, dc, false)

661

59

},

662

59

);

663

664

59

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

665

666

59

            res?;

667

60

668

669

58

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

670

671

58

        let mask_result = match values.mask_type() {

672

57

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

673

1

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

674

};

675

676

58

        let mask = mask_result.into_image_surface()?;

677

678

58

        Ok(Some(mask))

679

61

680

681

2007181

    fn is_rendering_cancelled(&self) -> bool {

682

2007181

        match &self.config.cancellable {

683

2007179

            None => false,

684

2

            Some(cancellable) => cancellable.is_cancelled(),

685

686

2007181

687

688

    /// Checks whether the rendering has been cancelled in the middle.

689

///

690

    /// If so, returns an Err.  This is used from [`DrawingCtx::with_discrete_layer`] to

691

    /// exit early instead of proceeding with rendering.

692

2006062

    fn check_cancellation(&self) -> Result<(), InternalRenderingError> {

693

2006062

        if self.is_rendering_cancelled() {

694

2

            return Err(InternalRenderingError::Cancelled);

695

696

697

2006060

        Ok(())

698

2006062

699

700

2005873

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

701

2005873

        if self.recursion_depth > limits::MAX_LAYER_NESTING_DEPTH {

702

3

            return Err(InternalRenderingError::LimitExceeded(

703

3

                ImplementationLimit::MaximumLayerNestingDepthExceeded,

704

));

705

706

707

2005870

        Ok(())

708

2005873

709

710

303

    fn filter_current_surface(

711

        &mut self,

712

        acquired_nodes: &mut AcquiredNodes<'_>,

713

        filter: &Filter,

714

        viewport: &Viewport,

715

        element_name: &str,

716

        bbox: &BoundingBox,

717

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

718

606

        let surface_to_filter = SharedImageSurface::copy_from_surface(

719

303

            &cairo::ImageSurface::try_from(self.cr.target()).unwrap(),

720

303

)?;

721

722

303

        let stroke_paint_source = Rc::new(filter.stroke_paint_source.to_user_space(

723

            &bbox.rect,

724

            viewport,

725

303

            &filter.normalize_values,

726

303

));

727

303

        let fill_paint_source = Rc::new(filter.fill_paint_source.to_user_space(

728

            &bbox.rect,

729

            viewport,

730

303

            &filter.normalize_values,

731

303

));

732

733

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

734

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

735

        // for primitive_units.  So, get the corresponding NormalizeParams

736

        // here and pass them down.

737

303

        let user_space_params = NormalizeParams::from_values(

738

303

            &filter.normalize_values,

739

303

            &viewport.with_units(CoordUnits::UserSpaceOnUse),

740

);

741

742

303

        let filtered_surface = self

743

            .run_filters(

744

                viewport,

745

303

                surface_to_filter,

746

                filter,

747

                acquired_nodes,

748

                element_name,

749

                &user_space_params,

750

303

                stroke_paint_source,

751

303

                fill_paint_source,

752

                bbox,

753

)?

754

            .into_image_surface()?;

755

756

303

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

757

758

303

        Ok(generic_surface.clone())

759

303

760

761

2003847

    fn draw_in_optional_new_viewport(

762

        &mut self,

763

        acquired_nodes: &mut AcquiredNodes<'_>,

764

        viewport: &Viewport,

765

        layout_viewport: &Option<LayoutViewport>,

766

        draw_fn: &mut dyn FnMut(

767

            &mut AcquiredNodes<'_>,

768

            &mut DrawingCtx,

769

            &Viewport,

770

        ) -> Result<BoundingBox, InternalRenderingError>,

771

    ) -> Result<BoundingBox, InternalRenderingError> {

772

2003847

        if let Some(layout_viewport) = layout_viewport.as_ref() {

773

            // FIXME: here we ignore the Some() result of push_new_viewport().  We do that because

774

            // the returned one is just a copy of the one that got passeed in, but with a changed

775

            // transform.  However, we are in fact not using that transform anywhere!

776

//

777

            // In case push_new_viewport() returns None, we just don't draw anything.

778

//

779

            // Note that push_new_viewport() changes the cr's transform.  However it will be restored

780

            // at the end of this function with set_matrix.

781

1283

            if let Some(new_viewport) = self.push_new_viewport(viewport, layout_viewport) {

782

1281

                draw_fn(acquired_nodes, self, &new_viewport)

783

            } else {

784

2

                Ok(self.empty_bbox())

785

786

        } else {

787

2002564

            draw_fn(acquired_nodes, self, viewport)

788

789

2003847

790

791

2006242

    fn draw_layer_internal(

792

        &mut self,

793

        stacking_ctx: &StackingContext,

794

        acquired_nodes: &mut AcquiredNodes<'_>,

795

        viewport: &Viewport,

796

        layout_viewport: Option<LayoutViewport>,

797

        clipping: bool,

798

        draw_fn: &mut dyn FnMut(

799

            &mut AcquiredNodes<'_>,

800

            &mut DrawingCtx,

801

            &Viewport,

802

        ) -> Result<BoundingBox, InternalRenderingError>,

803

    ) -> Result<BoundingBox, InternalRenderingError> {

804

2006242

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

805

806

2006241

        let orig_transform = self.get_transform();

807

808

        // See the comment above about "not using that transform anywhere" (the viewport's).

809

2006241

        let viewport = viewport.with_composed_transform(stacking_ctx.transform);

810

2006241

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

811

812

2006241

        let res = if clipping {

813

40

            self.draw_in_optional_new_viewport(acquired_nodes, &viewport, &layout_viewport, draw_fn)

814

        } else {

815

4010073

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

816

2003872

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

817

2

                    self.link_tag_begin(link_target);

818

819

820

2003872

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

821

822

2003872

                let affine_at_start = self.get_transform();

823

824

2003872

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

825

184

                    clip_to_rectangle(&self.cr, rect);

826

827

828

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

829

4007744

                self.clip_to_node(

830

2003872

                    &stacking_ctx.clip_in_user_space,

831

2003872

                    acquired_nodes,

832

2003872

                    &viewport,

833

2003872

                    &self.empty_bbox(),

834

1

)?;

835

836

2003871

                let should_isolate = stacking_ctx.should_isolate();

837

838

2003871

                let res = if should_isolate {

839

                    // Compute our assortment of affines

840

841

686

                    let affines = Box::new(CompositingAffines::new(

842

687

                        *affine_at_start,

843

687

                        self.initial_viewport.transform,

844

687

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

845

687

));

846

847

                    // Create temporary surface and its cr

848

849

686

                    let cr = match stacking_ctx.filter {

850

384

                        None => cairo::Context::new(

851

384

                            &self

852

384

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

853

384

)?,

854

                        Some(_) => {

855

302

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

856

303

857

};

858

859

687

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

860

861

687

                    let (source_surface, mut res, bbox) = {

862

687

                        let mut temporary_draw_ctx = self.nested(cr.clone());

863

864

                        // Draw!

865

866

1374

                        let res = with_saved_cr(&cr, || {

867

1374

                            temporary_draw_ctx.draw_in_optional_new_viewport(

868

687

                                acquired_nodes,

869

687

                                &viewport,

870

687

                                &layout_viewport,

871

687

                                draw_fn,

872

873

687

});

874

875

687

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

876

684

                            *bbox

877

                        } else {

878

3

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

879

};

880

881

1374

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

882

303

                            let filtered_surface = temporary_draw_ctx.filter_current_surface(

883

303

                                acquired_nodes,

884

                                filter,

885

303

                                &viewport,

886

303

                                &stacking_ctx.element_name,

887

                                &bbox,

888

)?;

889

890

                            // FIXME: "res" was declared mutable above so that we could overwrite it

891

                            // with the result of filtering, so that if filtering produces an error,

892

                            // then the masking below wouldn't take place.  Test for that and fix this;

893

                            // we are *not* modifying res in case of error.

894

303

                            (filtered_surface, res, bbox)

895

                        } else {

896

384

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

897

898

687

};

899

900

                    // Set temporary surface as source

901

902

1374

                    self.cr

903

687

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

904

687

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

905

906

                    // Clip

907

908

1374

                    self.cr.set_matrix(

909

687

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

910

);

911

1374

                    self.clip_to_node(

912

687

                        &stacking_ctx.clip_in_object_space,

913

687

                        acquired_nodes,

914

687

                        &viewport,

915

                        &bbox,

916

)?;

917

918

                    // Mask

919

920

687

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

921

125

                        res = res.and_then(|bbox| {

922

183

                            self.generate_cairo_mask(

923

61

                                mask_node,

924

61

                                &viewport,

925

61

                                affines.for_temporary_surface,

926

                                &bbox,

927

61

                                acquired_nodes,

928

929

121

                            .and_then(|mask_surf| {

930

60

                                if let Some(surf) = mask_surf {

931

58

                                    self.cr.push_group();

932

933

116

                                    self.cr.set_matrix(

934

58

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

935

);

936

58

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

937

938

118

                                    Ok(self.cr.pop_group_to_source()?)

939

58

                                } else {

940

2

                                    Ok(())

941

942

60

})

943

60

                            .map(|_: ()| bbox)

944

61

});

945

946

947

948

                        // Composite the temporary surface

949

950

1374

                        self.cr

951

687

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

952

687

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

953

954

687

                        if opacity < 1.0 {

955

313

                            self.cr.paint_with_alpha(opacity)?;

956

                        } else {

957

374

                            self.cr.paint()?;

958

959

960

961

687

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

962

687

res

963

687

                } else {

964

4006368

                    self.draw_in_optional_new_viewport(

965

2003184

                        acquired_nodes,

966

2003184

                        &viewport,

967

2003184

                        &layout_viewport,

968

2003184

                        draw_fn,

969

970

};

971

972

2003871

                if stacking_ctx.link_target.is_some() {

973

2

                    self.link_tag_end();

974

975

976

2003871

res

977

2003872

})

978

2006201

};

979

980

2006241

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

981

2006241

res

982

2006242

983

984

2005867

    pub fn with_discrete_layer(

985

        &mut self,

986

        stacking_ctx: &StackingContext,

987

        acquired_nodes: &mut AcquiredNodes<'_>,

988

        viewport: &Viewport,

989

        layout_viewport: Option<LayoutViewport>,

990

        clipping: bool,

991

        draw_fn: &mut dyn FnMut(

992

            &mut AcquiredNodes<'_>,

993

            &mut DrawingCtx,

994

            &Viewport,

995

        ) -> Result<BoundingBox, InternalRenderingError>,

996

    ) -> Result<BoundingBox, InternalRenderingError> {

997

2005867

        self.check_cancellation()?;

998

999

2005865

        self.recursion_depth += 1;

1000

1001

2005865

        match self.check_layer_nesting_depth() {

1002

            Ok(()) => {

1003

2005862

                let res = self.draw_layer_internal(

1004

                    stacking_ctx,

1005

                    acquired_nodes,

1006

                    viewport,

1007

                    layout_viewport,

1008

                    clipping,

1009

                    draw_fn,

1010

);

1011

1012

2005862

                self.recursion_depth -= 1;

1013

2005862

res

1014

2005862

1015

1016

3

            Err(e) => Err(e),

1017

1018

2005867

1019

1020

    /// Run the drawing function with the specified opacity

1021

50026

    fn with_alpha(

1022

        &mut self,

1023

        opacity: UnitInterval,

1024

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

1025

    ) -> Result<BoundingBox, InternalRenderingError> {

1026

50026

        let res;

1027

50026

        let UnitInterval(o) = opacity;

1028

100051

        if o < 1.0 {

1029

1

            self.cr.push_group();

1030

1

            res = draw_fn(self);

1031

1

            self.cr.pop_group_to_source()?;

1032

50027

            self.cr.paint_with_alpha(o)?;

1033

        } else {

1034

50025

            res = draw_fn(self);

1035

1036

1037

50026

res

1038

50026

1039

1040

    /// Start a Cairo tag for PDF links

1041

6

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

1042

6

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

1043

1044

6

        let cr = self.cr.clone();

1045

6

        cr.tag_begin(CAIRO_TAG_LINK, &attributes);

1046

6

1047

1048

    /// End a Cairo tag for PDF links

1049

6

    fn link_tag_end(&mut self) {

1050

6

        self.cr.tag_end(CAIRO_TAG_LINK);

1051

6

1052

1053

303

    fn run_filters(

1054

        &mut self,

1055

        viewport: &Viewport,

1056

        surface_to_filter: SharedImageSurface,

1057

        filter: &Filter,

1058

        acquired_nodes: &mut AcquiredNodes<'_>,

1059

        node_name: &str,

1060

        user_space_params: &NormalizeParams,

1061

        stroke_paint_source: Rc<UserSpacePaintSource>,

1062

        fill_paint_source: Rc<UserSpacePaintSource>,

1063

        node_bbox: &BoundingBox,

1064

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1065

303

        let session = self.session();

1066

1067

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

1068

//

1069

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

1070

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

1071

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

1072

//

1073

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

1074

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

1075

303

        let filter_specs = filter

1076

            .filter_list

1077

            .iter()

1078

609

            .map(|filter_value| {

1079

306

                filter_value.to_filter_spec(

1080

306

                    acquired_nodes,

1081

306

                    user_space_params,

1082

306

                    filter.current_color,

1083

306

                    viewport,

1084

306

                    session,

1085

306

                    node_name,

1086

1087

306

})

1088

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

1089

1090

303

        match filter_specs {

1091

300

            Ok(specs) => {

1092

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

1093

                // the final result is our return value.

1094

601

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

1095

301

                    filters::render(

1096

301

                        spec,

1097

301

                        stroke_paint_source.clone(),

1098

301

                        fill_paint_source.clone(),

1099

301

                        surface,

1100

301

                        acquired_nodes,

1101

301

                        self,

1102

301

                        *self.get_transform(),

1103

301

                        node_bbox,

1104

301

1105

301

})

1106

300

1107

1108

3

            Err(e) => {

1109

                rsvg_log!(

1110

3

                    self.session,

1111

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

1112

                    node_name,

1113

1114

);

1115

                // just return the original surface without filtering it

1116

3

                Ok(surface_to_filter)

1117

1118

1119

303

1120

1121

167

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

1122

167

        let g = match gradient.variant {

1123

128

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

1124

128

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

1125

128

1126

1127

            GradientVariant::Radial {

1128

39

cx,

1129

39

cy,

1130

39

r,

1131

39

fx,

1132

39

fy,

1133

39

fr,

1134

39

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

1135

};

1136

1137

167

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

1138

163

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

1139

1140

617

        for stop in &gradient.stops {

1141

454

            let UnitInterval(stop_offset) = stop.offset;

1142

1143

454

            let rgba = color_to_rgba(&stop.color);

1144

1145

453

            g.add_color_stop_rgba(

1146

                stop_offset,

1147

454

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

1148

454

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

1149

453

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

1150

453

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

1151

);

1152

1153

1154

329

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

1155

163

1156

1157

500033

    fn set_pattern(

1158

        &mut self,

1159

        pattern: &UserSpacePattern,

1160

        acquired_nodes: &mut AcquiredNodes<'_>,

1161

    ) -> Result<bool, InternalRenderingError> {

1162

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

1163

500033

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

1164

9

            return Ok(false);

1165

1166

1167

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

1168

500024

        let pattern_node_acquired = match pattern.acquire_pattern_node(acquired_nodes) {

1169

500024

            Ok(n) => n,

1170

1171

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

1172

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

1173

                return Ok(false);

1174

1175

1176

            _ => unreachable!(),

1177

500024

};

1178

1179

500024

        let pattern_node = pattern_node_acquired.get();

1180

1181

500024

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

1182

1183

500024

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

1184

500024

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

1185

1186

500024

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

1187

500024

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

1188

1189

500024

        if pw < 1 || ph < 1 {

1190

449998

            return Ok(false);

1191

1192

1193

50026

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

1194

50026

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

1195

1196

        // Apply the pattern transform

1197

100029

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

1198

23

            (pattern.coord_transform, pattern.content_transform)

1199

        } else {

1200

50003

1201

100006

                pattern

1202

                    .coord_transform

1203

50003

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

1204

50003

                pattern.content_transform.post_scale(scwscale, schscale),

1205

1206

};

1207

1208

        // Draw to another surface

1209

50026

        let surface = self

1210

.cr

1211

            .target()

1212

100052

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

1213

1214

50026

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

1215

1216

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

1217

1218

50026

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

1219

50026

        cr_pattern.set_matrix(transform.into());

1220

1221

        // Draw everything

1222

1223

1224

50026

            let mut pattern_draw_ctx = self.nested(cr_pattern);

1225

1226

50026

            let pattern_viewport = Viewport {

1227

50026

                dpi: self.config.dpi,

1228

50026

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

1229

50026

                transform: *transform,

1230

};

1231

1232

100052

            pattern_draw_ctx

1233

100052

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

1234

50026

                    let pattern_cascaded = CascadedValues::new_from_node(pattern_node);

1235

50026

                    let pattern_values = pattern_cascaded.get();

1236

1237

50026

                    let elt = pattern_node.borrow_element();

1238

1239

50026

                    let stacking_ctx = Box::new(StackingContext::new(

1240

50026

                        self.session(),

1241

50026

                        acquired_nodes,

1242

50026

                        &elt,

1243

50026

                        Transform::identity(),

1244

50026

                        None,

1245

                        pattern_values,

1246

));

1247

1248

50026

                    dc.with_discrete_layer(

1249

50026

                        &stacking_ctx,

1250

50026

                        acquired_nodes,

1251

50026

                        &pattern_viewport,

1252

50026

                        None,

1253

                        false,

1254

100052

                        &mut |an, dc, new_viewport| {

1255

100052

                            pattern_node.draw_children(

1256

an,

1257

50026

                                &pattern_cascaded,

1258

                                new_viewport,

1259

dc,

1260

                                false,

1261

1262

50026

},

1263

1264

50026

})

1265

50026

                .map(|_| ())?;

1266

50026

1267

1268

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

1269

50026

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

1270

1271

50026

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

1272

50026

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

1273

50026

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

1274

50026

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

1275

550059

            self.cr.set_source(&pattern)?;

1276

1277

1278

50026

        Ok(true)

1279

500033

1280

1281

1898784

    fn set_paint_source(

1282

        &mut self,

1283

        paint_source: &UserSpacePaintSource,

1284

        acquired_nodes: &mut AcquiredNodes<'_>,

1285

    ) -> Result<bool, InternalRenderingError> {

1286

1898784

        match *paint_source {

1287

163

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

1288

1898784

                self.set_gradient(gradient)?;

1289

163

                Ok(true)

1290

163

1291

500033

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

1292

500033

                if self.set_pattern(pattern, acquired_nodes)? {

1293

50026

                    Ok(true)

1294

450007

                } else if let Some(c) = c {

1295

9

                    set_source_color_on_cairo(&self.cr, c);

1296

9

                    Ok(true)

1297

                } else {

1298

449998

                    Ok(false)

1299

1300

1301

949317

            UserSpacePaintSource::SolidColor(ref c) => {

1302

949317

                set_source_color_on_cairo(&self.cr, c);

1303

949317

                Ok(true)

1304

949317

1305

449271

            UserSpacePaintSource::None => Ok(false),

1306

1307

1898784

1308

1309

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

1310

13

    pub fn get_paint_source_surface(

1311

        &mut self,

1312

        width: i32,

1313

        height: i32,

1314

        acquired_nodes: &mut AcquiredNodes<'_>,

1315

        paint_source: &UserSpacePaintSource,

1316

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1317

13

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

1318

1319

26

        surface.draw(&mut |cr| {

1320

13

            let mut temporary_draw_ctx = self.nested(cr);

1321

1322

            // FIXME: we are ignoring any error

1323

1324

            let had_paint_server =

1325

13

                temporary_draw_ctx.set_paint_source(paint_source, acquired_nodes)?;

1326

13

            if had_paint_server {

1327

26

                temporary_draw_ctx.cr.paint()?;

1328

1329

1330

13

            Ok(())

1331

13

        })?;

1332

1333

13

        Ok(surface.share()?)

1334

13

1335

1336

948517

    fn stroke(

1337

        &mut self,

1338

        cr: &cairo::Context,

1339

        acquired_nodes: &mut AcquiredNodes<'_>,

1340

        paint_source: &UserSpacePaintSource,

1341

    ) -> Result<(), InternalRenderingError> {

1342

948517

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

1343

948517

        if had_paint_server {

1344

1449662

            cr.stroke_preserve()?;

1345

1346

1347

948517

        Ok(())

1348

948517

1349

1350

948162

    fn fill(

1351

        &mut self,

1352

        cr: &cairo::Context,

1353

        acquired_nodes: &mut AcquiredNodes<'_>,

1354

        paint_source: &UserSpacePaintSource,

1355

    ) -> Result<(), InternalRenderingError> {

1356

948162

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

1357

948162

        if had_paint_server {

1358

1446373

            cr.fill_preserve()?;

1359

1360

1361

948162

        Ok(())

1362

948162

1363

1364

949348

    pub fn draw_layer(

1365

        &mut self,

1366

        layer: &Layer,

1367

        acquired_nodes: &mut AcquiredNodes<'_>,

1368

        clipping: bool,

1369

        viewport: &Viewport,

1370

    ) -> Result<BoundingBox, InternalRenderingError> {

1371

949348

        match &layer.kind {

1372

1896674

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

1373

948337

                shape,

1374

                &layer.stacking_ctx,

1375

                acquired_nodes,

1376

                clipping,

1377

                viewport,

1378

),

1379

1806

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

1380

903

                text,

1381

                &layer.stacking_ctx,

1382

                acquired_nodes,

1383

                clipping,

1384

                viewport,

1385

),

1386

216

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

1387

108

                image,

1388

                &layer.stacking_ctx,

1389

                acquired_nodes,

1390

                clipping,

1391

                viewport,

1392

),

1393

            LayerKind::Group(group) => self.draw_group(

1394

                group,

1395

                &layer.stacking_ctx,

1396

                acquired_nodes,

1397

                clipping,

1398

                viewport,

1399

),

1400

1401

949348

1402

1403

948329

    fn draw_shape(

1404

        &mut self,

1405

        shape: &Shape,

1406

        stacking_ctx: &StackingContext,

1407

        acquired_nodes: &mut AcquiredNodes<'_>,

1408

        clipping: bool,

1409

        viewport: &Viewport,

1410

    ) -> Result<BoundingBox, InternalRenderingError> {

1411

948329

        let (cairo_path, stroke_paint, fill_paint) = match &shape.path {

1412

            layout::Path::Validated {

1413

948307

                cairo_path,

1414

                extents: Some(_),

1415

948307

                stroke_paint,

1416

948307

                fill_paint,

1417

..

1418

948307

            } => (cairo_path, stroke_paint, fill_paint),

1419

18

            layout::Path::Validated { extents: None, .. } => return Ok(self.empty_bbox()),

1420

4

            layout::Path::Invalid(_) => return Ok(self.empty_bbox()),

1421

};

1422

1423

948307

        self.with_discrete_layer(

1424

            stacking_ctx,

1425

            acquired_nodes,

1426

            viewport,

1427

948307

            None,

1428

            clipping,

1429

1915396

            &mut |an, dc, new_viewport| {

1430

967089

                let cr = dc.cr.clone();

1431

1432

967089

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

1433

948645

                let mut path_helper = PathHelper::new(&cr, transform, cairo_path);

1434

1435

948645

                if clipping {

1436

39

                    if shape.is_visible {

1437

38

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

1438

38

                        path_helper.set()?;

1439

1440

39

                    return Ok(dc.empty_bbox());

1441

1442

1443

948606

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

1444

1445

948833

                setup_cr_for_stroke(&cr, &shape.stroke);

1446

1447

947921

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

1448

1449

948867

                path_helper.set()?;

1450

947079

                let bbox = compute_stroke_and_fill_box(

1451

                    &cr,

1452

949843

                    &shape.stroke,

1453

949843

                    stroke_paint,

1454

949843

                    &dc.initial_viewport,

1455

)?;

1456

1457

948270

                if shape.is_visible {

1458

3793608

                    for &target in &shape.paint_order.targets {

1459

                        // fill and stroke operations will preserve the path.

1460

                        // markers operation will clear the path.

1461

2844745

                        match target {

1462

                            PaintTarget::Fill => {

1463

948061

                                path_helper.set()?;

1464

947983

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

1465

1466

1467

                            PaintTarget::Stroke => {

1468

948115

                                path_helper.set()?;

1469

948065

                                let backup_matrix = if shape.stroke.non_scaling {

1470

1

                                    let matrix = cr.matrix();

1471

1

                                    cr.set_matrix(

1472

1

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

1473

                                            .into(),

1474

);

1475

1

                                    Some(matrix)

1476

                                } else {

1477

948063

                                    None

1478

};

1479

1915153

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

1480

948468

                                if let Some(matrix) = backup_matrix {

1481

1

                                    cr.set_matrix(matrix);

1482

1483

1484

1485

948743

                            PaintTarget::Markers => {

1486

948569

                                path_helper.unset();

1487

948536

                                marker::render_markers_for_shape(

1488

949072

                                    shape,

1489

                                    new_viewport,

1490

dc,

1491

an,

1492

949072

                                    clipping,

1493

)?;

1494

1495

1496

1497

1498

1499

954273

                path_helper.unset();

1500

948672

                Ok(bbox)

1501

948711

},

1502

1503

948329

1504

1505

108

    fn paint_surface(

1506

        &mut self,

1507

        surface: &SharedImageSurface,

1508

        width: f64,

1509

        height: f64,

1510

        image_rendering: ImageRendering,

1511

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

1512

108

        let cr = self.cr.clone();

1513

1514

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

1515

//

1516

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

1517

        // transparency outside of the image producing incorrect results.

1518

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

1519

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

1520

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

1521

108

        let ptn = surface.to_cairo_pattern();

1522

108

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

1523

1524

108

        let interpolation = Interpolation::from(image_rendering);

1525

1526

108

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

1527

216

        cr.set_source(&ptn)?;

1528

1529

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

1530

108

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

1531

1532

108

        cr.paint()

1533

108

1534

1535

108

    fn draw_image(

1536

        &mut self,

1537

        image: &Image,

1538

        stacking_ctx: &StackingContext,

1539

        acquired_nodes: &mut AcquiredNodes<'_>,

1540

        clipping: bool,

1541

        viewport: &Viewport,

1542

    ) -> Result<BoundingBox, InternalRenderingError> {

1543

108

        let image_width = image.surface.width();

1544

108

        let image_height = image.surface.height();

1545

108

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

1546

            return Ok(self.empty_bbox());

1547

1548

1549

108

        let image_width = f64::from(image_width);

1550

108

        let image_height = f64::from(image_height);

1551

108

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

1552

1553

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

1554

        // and not by the final computed image bounds.

1555

108

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

1556

1557

108

        let layout_viewport = LayoutViewport {

1558

108

            vbox: Some(vbox),

1559

108

            geometry: image.rect,

1560

108

            preserve_aspect_ratio: image.aspect,

1561

108

            overflow: image.overflow,

1562

};

1563

1564

108

        if image.is_visible {

1565

108

            self.with_discrete_layer(

1566

                stacking_ctx,

1567

                acquired_nodes,

1568

                viewport,

1569

108

                Some(layout_viewport),

1570

                clipping,

1571

216

                &mut |_an, dc, _new_viewport| {

1572

216

                    dc.paint_surface(

1573

108

                        &image.surface,

1574

108

                        image_width,

1575

108

                        image_height,

1576

108

                        image.image_rendering,

1577

)?;

1578

1579

108

                    Ok(bounds)

1580

108

},

1581

1582

        } else {

1583

            Ok(bounds)

1584

1585

108

1586

1587

    fn draw_group(

1588

        &mut self,

1589

        _group: &Group,

1590

        _stacking_ctx: &StackingContext,

1591

        _acquired_nodes: &mut AcquiredNodes<'_>,

1592

        _clipping: bool,

1593

        _viewport: &Viewport,

1594

    ) -> Result<BoundingBox, InternalRenderingError> {

1595

        unimplemented!()

1596

1597

1598

1028

    fn draw_text_span(

1599

        &mut self,

1600

        span: &TextSpan,

1601

        acquired_nodes: &mut AcquiredNodes<'_>,

1602

        clipping: bool,

1603

    ) -> Result<BoundingBox, InternalRenderingError> {

1604

1028

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

1605

1028

        if path.is_empty() {

1606

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

1607

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

1608

            // empty rectangle.

1609

59

            return Ok(self.empty_bbox());

1610

1611

1612

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

1613

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

1614

        // viewers.

1615

967

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

1616

1617

1934

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

1618

1934

            self.cr

1619

967

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

1620

1621

967

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

1622

1623

967

            if clipping {

1624

1

                path.to_cairo_context(&self.cr)?;

1625

1

                return Ok(self.empty_bbox());

1626

1627

1628

966

            path.to_cairo_context(&self.cr)?;

1629

966

            let bbox = compute_stroke_and_fill_box(

1630

966

                &self.cr,

1631

966

                &span.stroke,

1632

966

                &span.stroke_paint,

1633

966

                &self.initial_viewport,

1634

)?;

1635

966

            self.cr.new_path();

1636

1637

966

            if span.is_visible {

1638

956

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

1639

4

                    self.link_tag_begin(link_target);

1640

1641

1642

3823

                for &target in &span.paint_order.targets {

1643

2867

                    match target {

1644

                        PaintTarget::Fill => {

1645

                            let had_paint_server =

1646

956

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

1647

1648

956

                            if had_paint_server {

1649

953

                                if can_use_text_as_path {

1650

949

                                    path.to_cairo_context(&self.cr)?;

1651

949

                                    self.cr.fill()?;

1652

949

                                    self.cr.new_path();

1653

                                } else {

1654

4

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

1655

1656

4

                                    let matrix = self.cr.matrix();

1657

1658

4

                                    let rotation_from_gravity = span.gravity.to_rotation();

1659

4

                                    if !rotation_from_gravity.approx_eq_cairo(0.0) {

1660

                                        self.cr.rotate(-rotation_from_gravity);

1661

1662

1663

4

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

1664

4

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

1665

1666

4

                                    self.cr.set_matrix(matrix);

1667

1668

1669

1670

1671

                        PaintTarget::Stroke => {

1672

                            let had_paint_server =

1673

956

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

1674

1675

956

                            if had_paint_server {

1676

35

                                path.to_cairo_context(&self.cr)?;

1677

35

                                self.cr.stroke()?;

1678

35

                                self.cr.new_path();

1679

1680

1681

1682

                        PaintTarget::Markers => {}

1683

1684

1685

1686

956

                if span.link_target.is_some() {

1687

4

                    self.link_tag_end();

1688

1689

1690

1691

966

            Ok(bbox)

1692

967

})

1693

1026

1694

1695

903

    fn draw_text(

1696

        &mut self,

1697

        text: &Text,

1698

        stacking_ctx: &StackingContext,

1699

        acquired_nodes: &mut AcquiredNodes<'_>,

1700

        clipping: bool,

1701

        viewport: &Viewport,

1702

    ) -> Result<BoundingBox, InternalRenderingError> {

1703

903

        self.with_discrete_layer(

1704

            stacking_ctx,

1705

            acquired_nodes,

1706

            viewport,

1707

903

            None,

1708

            clipping,

1709

1806

            &mut |an, dc, _new_viewport| {

1710

903

                let mut bbox = dc.empty_bbox();

1711

1712

1929

                for span in &text.spans {

1713

1026

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

1714

1026

                    bbox.insert(&span_bbox);

1715

1716

1717

903

                Ok(bbox)

1718

903

},

1719

1720

903

1721

1722

10

    pub fn get_snapshot(

1723

        &self,

1724

        width: i32,

1725

        height: i32,

1726

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1727

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

1728

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

1729

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

1730

//

1731

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

1732

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

1733

//

1734

        // Deprecation:

1735

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

1736

//

1737

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

1738

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

1739

//

1740

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

1741

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

1742

10

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

1743

1744

20

        surface.draw(&mut |cr| {

1745

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

1746

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

1747

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

1748

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

1749

22

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

1750

12

                let affines = CompositingAffines::new(

1751

12

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

1752

12

                    self.initial_viewport.transform,

1753

                    depth,

1754

);

1755

1756

12

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

1757

12

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

1758

22

                cr.paint()?;

1759

10

1760

1761

10

            Ok(())

1762

10

        })?;

1763

1764

10

        Ok(surface.share()?)

1765

10

1766

1767

25

    pub fn draw_node_to_surface(

1768

        &mut self,

1769

        node: &Node,

1770

        acquired_nodes: &mut AcquiredNodes<'_>,

1771

        cascaded: &CascadedValues<'_>,

1772

        affine: Transform,

1773

        width: i32,

1774

        height: i32,

1775

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1776

25

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

1777

1778

25

        let save_cr = self.cr.clone();

1779

1780

1781

25

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

1782

50

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

1783

1784

25

            self.cr = cr;

1785

25

            let viewport = Viewport {

1786

25

                dpi: self.config.dpi,

1787

                transform: affine,

1788

25

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

1789

};

1790

1791

25

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

1792

25

1793

1794

25

        self.cr = save_cr;

1795

1796

25

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

1797

25

1798

1799

1460253

    pub fn draw_node_from_stack(

1800

        &mut self,

1801

        node: &Node,

1802

        acquired_nodes: &mut AcquiredNodes<'_>,

1803

        cascaded: &CascadedValues<'_>,

1804

        viewport: &Viewport,

1805

        clipping: bool,

1806

    ) -> Result<BoundingBox, InternalRenderingError> {

1807

1460253

        let stack_top = self.drawsub_stack.pop();

1808

1809

1460253

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

1810

2596

            top == node

1811

        } else {

1812

1457657

            true

1813

};

1814

1815

1460973

        let res = if draw {

1816

1458892

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

1817

        } else {

1818

1037

            Ok(self.empty_bbox())

1819

};

1820

1821

1459619

        if let Some(top) = stack_top {

1822

2282

            self.drawsub_stack.push(top);

1823

1824

1825

1459619

res

1826

1459619

1827

1828

500404

    pub fn draw_from_use_node(

1829

        &mut self,

1830

        node: &Node,

1831

        acquired_nodes: &mut AcquiredNodes<'_>,

1832

        values: &ComputedValues,

1833

        use_rect: Rect,

1834

        link: &NodeId,

1835

        clipping: bool,

1836

        viewport: &Viewport,

1837

        fill_paint: Rc<PaintSource>,

1838

        stroke_paint: Rc<PaintSource>,

1839

    ) -> Result<BoundingBox, InternalRenderingError> {

1840

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

1841

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

1842

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

1843

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

1844

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

1845

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

1846

        // references can be caught.

1847

500404

        let _self_acquired = match acquired_nodes.acquire_ref(node) {

1848

500289

            Ok(n) => n,

1849

1850

139

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

1851

139

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

1852

139

                return Err(InternalRenderingError::CircularReference(circular));

1853

1854

1855

            _ => unreachable!(),

1856

500384

};

1857

1858

500245

        let acquired = match acquired_nodes.acquire(link) {

1859

500241

            Ok(acquired) => acquired,

1860

1861

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

1862

                rsvg_log!(

1863

                    self.session,

1864

                    "circular reference from {} to element {}",

1865

                    node,

1866

                    circular

1867

);

1868

                return Err(InternalRenderingError::CircularReference(circular));

1869

1870

1871

            Err(AcquireError::MaxReferencesExceeded) => {

1872

1

                return Err(InternalRenderingError::LimitExceeded(

1873

1

                    ImplementationLimit::TooManyReferencedElements,

1874

));

1875

1876

1877

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

1878

1879

25

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

1880

                rsvg_log!(

1881

25

                    self.session,

1882

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

1883

                    node,

1884

                    node_id

1885

);

1886

25

                return Ok(self.empty_bbox());

1887

25

1888

26

};

1889

1890

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

1891

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

1892

500241

        if use_rect.is_empty() {

1893

            return Ok(self.empty_bbox());

1894

1895

1896

500219

        let child = acquired.get();

1897

1898

500219

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

1899

1

            return Ok(self.empty_bbox());

1900

1901

1902

500218

        let orig_transform = self.get_transform();

1903

1904

        // FMQ: here

1905

1000436

        self.cr

1906

1000622

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

1907

1908

500218

        let use_element = node.borrow_element();

1909

1910

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

1911

            let symbol = borrow_element_as!(child, Symbol);

1912

9

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

1913

500217

        } else if is_element_of_type!(child, Svg) {

1914

            let svg = borrow_element_as!(child, Svg);

1915

1

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

1916

1

        } else {

1917

500208

            None

1918

};

1919

1920

500218

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

1921

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

1922

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

1923

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

1924

1925

10

            let elt = child.borrow_element();

1926

1927

10

            let child_values = elt.get_computed_values();

1928

1929

10

            let stacking_ctx = Box::new(StackingContext::new(

1930

10

                self.session(),

1931

                acquired_nodes,

1932

10

                &use_element,

1933

10

                Transform::identity(),

1934

10

                None,

1935

                values,

1936

));

1937

1938

10

            let layout_viewport = LayoutViewport {

1939

                vbox,

1940

                geometry: use_rect,

1941

                preserve_aspect_ratio,

1942

10

                overflow: child_values.overflow(),

1943

};

1944

1945

10

            self.with_discrete_layer(

1946

10

                &stacking_ctx,

1947

                acquired_nodes,

1948

                viewport,

1949

10

                Some(layout_viewport),

1950

                clipping,

1951

20

                &mut |an, dc, new_viewport| {

1952

20

                    child.draw_children(

1953

an,

1954

10

                        &CascadedValues::new_from_values(

1955

10

                            child,

1956

10

                            values,

1957

10

                            Some(fill_paint.clone()),

1958

10

                            Some(stroke_paint.clone()),

1959

10

),

1960

                        new_viewport,

1961

dc,

1962

10

                        clipping,

1963

1964

10

},

1965

10

1966

10

        } else {

1967

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

1968

1969

500208

            let stacking_ctx = Box::new(StackingContext::new(

1970

500208

                self.session(),

1971

                acquired_nodes,

1972

500208

                &use_element,

1973

500208

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

1974

500208

                None,

1975

                values,

1976

));

1977

1978

500208

            self.with_discrete_layer(

1979

500208

                &stacking_ctx,

1980

                acquired_nodes,

1981

                viewport,

1982

500208

                None,

1983

                clipping,

1984

1000415

                &mut |an, dc, new_viewport| {

1985

1000414

                    child.draw(

1986

an,

1987

500207

                        &CascadedValues::new_from_values(

1988

500207

                            child,

1989

500207

                            values,

1990

500207

                            Some(fill_paint.clone()),

1991

500207

                            Some(stroke_paint.clone()),

1992

500207

),

1993

                        new_viewport,

1994

dc,

1995

500207

                        clipping,

1996

1997

500207

},

1998

500228

1999

500208

};

2000

2001

500218

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

2002

2003

1000399

        if let Ok(bbox) = res {

2004

500181

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

2005

500181

            res_bbox.insert(&bbox);

2006

500181

            Ok(res_bbox)

2007

        } else {

2008

37

res

2009

2010

500383

2011

2012

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

2013

///

2014

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

2015

903

    pub fn get_font_options(&self) -> FontOptions {

2016

903

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

2017

903

        if self.config.testing {

2018

855

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

2019

2020

2021

903

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

2022

903

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

2023

2024

903

        FontOptions { options }

2025

903

2026

2027

2028

impl From<ImageRendering> for Interpolation {

2029

175

    fn from(r: ImageRendering) -> Interpolation {

2030

175

        match r {

2031

            ImageRendering::Pixelated

2032

            | ImageRendering::CrispEdges

2033

1

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

2034

2035

            ImageRendering::Smooth

2036

            | ImageRendering::OptimizeQuality

2037

            | ImageRendering::HighQuality

2038

174

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

2039

2040

175

2041

2042

2043

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

2044

1028

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

2045

1028

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

2046

1028

    let context = font_map.create_context();

2047

2048

1028

    context.set_round_glyph_positions(false);

2049

2050

1028

    let pango_matrix = PangoMatrix {

2051

1028

        xx: transform.xx,

2052

1028

        xy: transform.xy,

2053

1028

        yx: transform.yx,

2054

1028

        yy: transform.yy,

2055

1028

        x0: transform.x0,

2056

1028

        y0: transform.y0,

2057

};

2058

2059

1028

    let pango_matrix_ptr: *const PangoMatrix = &pango_matrix;

2060

2061

1028

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

2062

1028

    context.set_matrix(Some(&matrix));

2063

2064

1028

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

2065

2066

    // Pango says this about pango_cairo_context_set_resolution():

2067

//

2068

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

2069

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

2070

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

2071

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

2072

//

2073

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

2074

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

2075

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

2076

    // to the size values we give it.

2077

//

2078

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

2079

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

2080

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

2081

    // code.

2082

1028

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

2083

2084

1028

    context

2085

1028

2086

2087

949367

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

2088

949367

    let rgba = color_to_rgba(color);

2089

2090

949367

    cr.set_source_rgba(

2091

949367

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

2092

949367

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

2093

949367

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

2094

949367

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

2095

);

2096

949367

2097

2098

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

2099

/// Does not clear the current path first.

2100

1026

fn pango_layout_to_cairo(

2101

    x: f64,

2102

    y: f64,

2103

    layout: &pango::Layout,

2104

    gravity: pango::Gravity,

2105

    cr: &cairo::Context,

2106

) {

2107

1026

    let rotation_from_gravity = gravity.to_rotation();

2108

1026

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

2109

        Some(-rotation_from_gravity)

2110

    } else {

2111

1026

        None

2112

};

2113

2114

1026

    cr.move_to(x, y);

2115

2116

1026

    let matrix = cr.matrix();

2117

1026

    if let Some(rot) = rotation {

2118

        cr.rotate(rot);

2119

2120

2121

1026

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

2122

1026

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

2123

1026

    cr.set_matrix(matrix);

2124

1026

2125

2126

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

2127

1028

fn pango_layout_to_cairo_path(

2128

    x: f64,

2129

    y: f64,

2130

    layout: &pango::Layout,

2131

    gravity: pango::Gravity,

2132

) -> Result<CairoPath, InternalRenderingError> {

2133

1028

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

2134

1028

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

2135

2136

1027

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

2137

2138

1026

    let cairo_path = cr.copy_path()?;

2139

1025

    Ok(CairoPath::from_cairo(cairo_path))

2140

1025

2141

2142

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

2143

43

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

2144

    use ElementData::*;

2145

2146

43

    matches!(

2147

43

        element.element_data,

2148

        Circle(_)

2149

            | Ellipse(_)

2150

            | Line(_)

2151

            | Path(_)

2152

            | Polygon(_)

2153

            | Polyline(_)

2154

            | Rect(_)

2155

            | Text(_)

2156

            | Use(_)

2157

2158

43

2159

2160

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

2161

1

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

2162

    use ElementData::*;

2163

2164

1

    matches!(

2165

1

        element.element_data,

2166

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

2167

2168

1

2169

2170

#[derive(Debug)]

2171

struct CompositingAffines {

2172

    pub outside_temporary_surface: Transform,

2173

    #[allow(unused)]

2174

    pub initial: Transform,

2175

    pub for_temporary_surface: Transform,

2176

    pub compositing: Transform,

2177

    pub for_snapshot: Transform,

2178

2179

2180

impl CompositingAffines {

2181

1121

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

2182

1121

        let is_topmost_temporary_surface = cr_stack_depth == 0;

2183

2184

1121

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

2185

2186

1121

        let outside_temporary_surface = if is_topmost_temporary_surface {

2187

645

            current

2188

        } else {

2189

476

            current.post_transform(&initial_inverse)

2190

};

2191

2192

1121

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

2193

2194

1121

        let for_temporary_surface = if is_topmost_temporary_surface {

2195

645

            current

2196

                .post_transform(&initial_inverse)

2197

                .post_scale(scale_x, scale_y)

2198

        } else {

2199

476

            current

2200

};

2201

2202

1121

        let compositing = if is_topmost_temporary_surface {

2203

645

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

2204

        } else {

2205

476

            Transform::identity()

2206

};

2207

2208

1121

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

2209

2210

1121

        CompositingAffines {

2211

1121

            outside_temporary_surface,

2212

            initial,

2213

1121

            for_temporary_surface,

2214

1121

            compositing,

2215

            for_snapshot,

2216

2217

1121

2218

2219

2220

948734

fn compute_stroke_and_fill_extents(

2221

    cr: &cairo::Context,

2222

    stroke: &Stroke,

2223

    stroke_paint_source: &UserSpacePaintSource,

2224

    initial_viewport: &Viewport,

2225

) -> Result<PathExtents, InternalRenderingError> {

2226

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

2227

    // _rendering_ time speedups, are these rather expensive operations

2228

    // really needed here? */

2229

948734

    let backup_tolerance = cr.tolerance();

2230

948734

    cr.set_tolerance(1.0);

2231

2232

    // Bounding box for fill

2233

//

2234

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

2235

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

2236

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

2237

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

2238

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

2239

2240

948734

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

2241

948734

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

2242

504038

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

2243

    } else {

2244

444696

        None

2245

};

2246

2247

    // Bounding box for stroke

2248

//

2249

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

2250

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

2251

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

2252

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

2253

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

2254

//

2255

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

2256

    // bounding box if so.

2257

2258

1896772

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

2259

948038

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

2260

2261

501179

        let backup_matrix = if stroke.non_scaling {

2262

1

            let matrix = cr.matrix();

2263

948735

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

2264

1

            Some(matrix)

2265

        } else {

2266

501177

            None

2267

};

2268

501178

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

2269

501178

        if let Some(matrix) = backup_matrix {

2270

1

            cr.set_matrix(matrix);

2271

2272

501178

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

2273

    } else {

2274

447556

        None

2275

};

2276

2277

    // objectBoundingBox

2278

2279

948734

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

2280

948734

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

2281

2282

    // restore tolerance

2283

2284

948734

    cr.set_tolerance(backup_tolerance);

2285

2286

948734

    Ok(PathExtents {

2287

        path_only: path_extents,

2288

948734

        fill: fill_extents,

2289

948734

        stroke: stroke_extents,

2290

})

2291

948734

2292

2293

949872

fn compute_stroke_and_fill_box(

2294

    cr: &cairo::Context,

2295

    stroke: &Stroke,

2296

    stroke_paint_source: &UserSpacePaintSource,

2297

    initial_viewport: &Viewport,

2298

) -> Result<BoundingBox, InternalRenderingError> {

2299

    let extents =

2300

949872

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

2301

2302

949872

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

2303

444466

        (None, None) => None,

2304

4228

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

2305

230

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

2306

500948

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

2307

};

2308

2309

949872

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

2310

2311

949872

    if let Some(rect) = extents.path_only {

2312

949398

        bbox = bbox.with_rect(rect);

2313

2314

2315

949872

    if let Some(ink_rect) = ink_rect {

2316

505406

        bbox = bbox.with_ink_rect(ink_rect);

2317

2318

2319

949872

    Ok(bbox)

2320

949872

2321

2322

949056

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

2323

949056

    cr.set_line_width(stroke.width);

2324

949056

    cr.set_miter_limit(stroke.miter_limit.0);

2325

949056

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

2326

949056

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

2327

2328

949056

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

2329

2330

949056

    if total_length > 0.0 {

2331

106

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

2332

    } else {

2333

948950

        cr.set_dash(&[], 0.0);

2334

2335

949056

2336

2337

/// escape quotes and backslashes with backslash

2338

6

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

2339

    let regex = {

2340

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

2341

9

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

2342

};

2343

2344

6

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

2345

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

2346

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

2347

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

2348

            _ => unreachable!(),

2349

2350

})

2351

6

2352

2353

529

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

2354

529

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

2355

529

    cr.clip();

2356

529

2357

2358

impl From<SpreadMethod> for cairo::Extend {

2359

163

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

2360

163

        match s {

2361

157

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

2362

3

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

2363

3

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

2364

2365

163

2366

2367

2368

impl From<StrokeLinejoin> for cairo::LineJoin {

2369

948898

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

2370

948898

        match j {

2371

948765

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

2372

131

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

2373

2

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

2374

2375

948898

2376

2377

2378

impl From<StrokeLinecap> for cairo::LineCap {

2379

949259

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

2380

949259

        match j {

2381

949071

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

2382

156

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

2383

32

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

2384

2385

949259

2386

2387

2388

impl From<MixBlendMode> for cairo::Operator {

2389

687

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

2390

        use cairo::Operator;

2391

2392

687

        match m {

2393

671

            MixBlendMode::Normal => Operator::Over,

2394

1

            MixBlendMode::Multiply => Operator::Multiply,

2395

1

            MixBlendMode::Screen => Operator::Screen,

2396

1

            MixBlendMode::Overlay => Operator::Overlay,

2397

1

            MixBlendMode::Darken => Operator::Darken,

2398

1

            MixBlendMode::Lighten => Operator::Lighten,

2399

1

            MixBlendMode::ColorDodge => Operator::ColorDodge,

2400

1

            MixBlendMode::ColorBurn => Operator::ColorBurn,

2401

1

            MixBlendMode::HardLight => Operator::HardLight,

2402

1

            MixBlendMode::SoftLight => Operator::SoftLight,

2403

2

            MixBlendMode::Difference => Operator::Difference,

2404

1

            MixBlendMode::Exclusion => Operator::Exclusion,

2405

1

            MixBlendMode::Hue => Operator::HslHue,

2406

1

            MixBlendMode::Saturation => Operator::HslSaturation,

2407

1

            MixBlendMode::Color => Operator::HslColor,

2408

1

            MixBlendMode::Luminosity => Operator::HslLuminosity,

2409

2410

687

2411

2412

2413

impl From<ClipRule> for cairo::FillRule {

2414

38

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

2415

38

        match c {

2416

37

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

2417

1

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

2418

2419

38

2420

2421

2422

impl From<FillRule> for cairo::FillRule {

2423

947884

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

2424

947884

        match f {

2425

947720

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

2426

164

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

2427

2428

947884

2429

2430

2431

impl From<ShapeRendering> for cairo::Antialias {

2432

948494

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

2433

948494

        match sr {

2434

948481

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

2435

13

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

2436

2437

948494

2438

2439

2440

impl From<TextRendering> for cairo::Antialias {

2441

966

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

2442

966

        match tr {

2443

            TextRendering::Auto

2444

            | TextRendering::OptimizeLegibility

2445

966

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

2446

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

2447

2448

966

2449

2450

2451

impl From<cairo::Matrix> for Transform {

2452

    #[inline]

2453

10424640

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

2454

10424640

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

2455

10424640

2456

2457

2458

impl From<ValidTransform> for cairo::Matrix {

2459

    #[inline]

2460

6064638

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

2461

6064638

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

2462

6064638

2463

2464

2465

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

2466

///

2467

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

2468

/// what that coordinate system is.

2469

pub struct PathExtents {

2470

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

2471

    pub path_only: Option<Rect>,

2472

2473

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

2474

    pub fill: Option<Rect>,

2475

2476

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

2477

    pub stroke: Option<Rect>,

2478