Grcov report - drawing

1

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

2

3

use float_cmp::approx_eq;

4

use glib::translate::*;

5

use pango::ffi::PangoMatrix;

6

use pango::prelude::FontMapExt;

7

use regex::{Captures, Regex};

8

use std::cell::RefCell;

9

use std::convert::TryFrom;

10

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

11

use std::rc::Rc;

12

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

13

14

use crate::accept_language::UserLanguage;

15

use crate::bbox::BoundingBox;

16

use crate::color::color_to_rgba;

17

use crate::coord_units::CoordUnits;

18

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

19

use crate::dpi::Dpi;

20

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

21

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

22

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

23

use crate::float_eq_cairo::ApproxEqCairo;

24

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

25

use crate::layout::{

26

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

27

    TextSpan,

28

};

29

use crate::length::*;

30

use crate::marker;

31

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

32

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

33

use crate::path_builder::*;

34

use crate::pattern::UserSpacePattern;

35

use crate::properties::{

36

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

37

    PaintTarget, ShapeRendering, StrokeLinecap, StrokeLinejoin, TextRendering,

38

};

39

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

40

use crate::rsvg_log;

41

use crate::session::Session;

42

use crate::surface_utils::shared_surface::{

43

    ExclusiveImageSurface, Interpolation, SharedImageSurface, SurfaceType,

44

};

45

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

46

use crate::unit_interval::UnitInterval;

47

use crate::viewbox::ViewBox;

48

use crate::{borrow_element_as, is_element_of_type};

49

50

/// Opaque font options for a DrawingCtx.

51

///

52

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

53

pub struct FontOptions {

54

    options: cairo::FontOptions,

55

56

57

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

58

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

59

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

60

struct PathHelper<'a> {

61

    cr: &'a cairo::Context,

62

    transform: ValidTransform,

63

    path: &'a Path,

64

    is_square_linecap: bool,

65

    has_path: Option<bool>,

66

67

68

impl<'a> PathHelper<'a> {

69

948187

    pub fn new(

70

        cr: &'a cairo::Context,

71

        transform: ValidTransform,

72

        path: &'a Path,

73

        linecap: StrokeLinecap,

74

    ) -> Self {

75

948187

        PathHelper {

76

cr,

77

            transform,

78

            path,

79

948187

            is_square_linecap: linecap == StrokeLinecap::Square,

80

948187

            has_path: None,

81

82

948187

83

84

2844112

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

85

2844112

        match self.has_path {

86

            Some(false) | None => {

87

948703

                self.has_path = Some(true);

88

948703

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

89

948703

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

90

91

1895409

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

92

93

2844112

94

95

1896109

    pub fn unset(&mut self) {

96

1896109

        match self.has_path {

97

            Some(true) | None => {

98

948659

                self.has_path = Some(false);

99

948659

                self.cr.new_path();

100

101

            Some(false) => {}

102

103

1896109

104

105

106

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

107

105594

#[derive(Clone)]

108

pub struct Viewport {

109

52797

    pub dpi: Dpi,

110

111

    /// Corners of the current coordinate space.

112

52797

    pub vbox: ViewBox,

113

114

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

115

52797

    transform: Transform,

116

117

118

impl Viewport {

119

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

120

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

121

166

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

122

166

        Viewport {

123

            dpi,

124

166

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

125

166

            transform: Default::default(),

126

127

166

128

129

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

130

///

131

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

132

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

133

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

134

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

135

///

136

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

137

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

138

    /// system unchanged.

139

501224

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

140

501224

        match units {

141

404

            CoordUnits::ObjectBoundingBox => Viewport {

142

404

                dpi: self.dpi,

143

404

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

144

404

                transform: self.transform,

145

404

},

146

147

500820

            CoordUnits::UserSpaceOnUse => Viewport {

148

500820

                dpi: self.dpi,

149

500820

                vbox: self.vbox,

150

500820

                transform: self.transform,

151

500820

},

152

153

501224

154

155

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

156

193

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

157

193

        Viewport {

158

193

            dpi: self.dpi,

159

193

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

160

193

            transform: self.transform,

161

162

193

163

164

165

pub struct DrawingCtx {

166

    session: Session,

167

168

    initial_viewport: Viewport,

169

170

    dpi: Dpi,

171

172

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

173

    cr: cairo::Context,

174

175

    user_language: UserLanguage,

176

177

    drawsub_stack: Vec<Node>,

178

179

    svg_nesting: SvgNesting,

180

181

    measuring: bool,

182

    testing: bool,

183

184

185

pub enum DrawingMode {

186

    LimitToStack { node: Node, root: Node },

187

188

    OnlyNode(Node),

189

190

191

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

192

///

193

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

194

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

195

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

196

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

197

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

198

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

199

#[derive(Copy, Clone)]

200

pub enum SvgNesting {

201

    Standalone,

202

    ReferencedFromImageElement,

203

204

205

/// The toplevel drawing routine.

206

///

207

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

208

1105

pub fn draw_tree(

209

    session: Session,

210

    mode: DrawingMode,

211

    cr: &cairo::Context,

212

    viewport_rect: Rect,

213

    user_language: &UserLanguage,

214

    dpi: Dpi,

215

    svg_nesting: SvgNesting,

216

    measuring: bool,

217

    testing: bool,

218

    acquired_nodes: &mut AcquiredNodes<'_>,

219

) -> Result<BoundingBox, InternalRenderingError> {

220

2218

    let (drawsub_stack, node) = match mode {

221

1087

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

222

223

18

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

224

};

225

226

1113

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

227

228

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

229

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

230

1105

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

231

1104

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

232

233

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

234

//

235

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

236

    // determine an initial viewport coordinate system and an

237

    // initial user coordinate system such that the two

238

    // coordinates systems are identical. The origin of both

239

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

240

    // viewport."

241

//

242

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

243

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

244

    // the top/left of the viewport"

245

246

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

247

1105

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

248

249

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

250

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

251

    // element and ignore the error.

252

2209

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

253

1104

    cr.set_matrix(valid_transform.into());

254

255

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

256

1108

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

257

1105

    let initial_viewport = Viewport {

258

        dpi,

259

1105

        vbox: ViewBox::from(viewport_rect),

260

        transform,

261

};

262

263

1105

    let mut draw_ctx = DrawingCtx::new(

264

1105

        session,

265

cr,

266

        &initial_viewport,

267

1105

        user_language.clone(),

268

        dpi,

269

        svg_nesting,

270

        measuring,

271

        testing,

272

1105

        drawsub_stack,

273

1105

);

274

275

1105

    let content_bbox = draw_ctx.draw_node_from_stack(

276

        &node,

277

        acquired_nodes,

278

        &cascaded,

279

        &initial_viewport,

280

        false,

281

1

)?;

282

283

1104

    user_bbox.insert(&content_bbox);

284

285

1104

    Ok(user_bbox)

286

1105

287

288

2009075

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

289

where

290

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

291

292

2009075

    cr.save()?;

293

2008028

    match f() {

294

2007684

        Ok(o) => {

295

4017767

            cr.restore()?;

296

2008138

            Ok(o)

297

2008138

298

299

37

        Err(e) => Err(e),

300

301

2008175

302

303

impl Drop for DrawingCtx {

304

51883

    fn drop(&mut self) {

305

51883

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

306

51883

307

308

309

const CAIRO_TAG_LINK: &str = "Link";

310

311

impl DrawingCtx {

312

1104

    fn new(

313

        session: Session,

314

        cr: &cairo::Context,

315

        initial_viewport: &Viewport,

316

        user_language: UserLanguage,

317

        dpi: Dpi,

318

        svg_nesting: SvgNesting,

319

        measuring: bool,

320

        testing: bool,

321

        drawsub_stack: Vec<Node>,

322

    ) -> DrawingCtx {

323

1102

        DrawingCtx {

324

1104

            session,

325

1104

            initial_viewport: initial_viewport.clone(),

326

            dpi,

327

1104

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

328

1102

            cr: cr.clone(),

329

1102

            user_language,

330

1102

            drawsub_stack,

331

            svg_nesting,

332

            measuring,

333

            testing,

334

335

1102

336

337

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

338

///

339

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

340

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

341

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

342

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

343

50778

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

344

50778

        let cr_stack = self.cr_stack.clone();

345

346

50778

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

347

348

50778

        DrawingCtx {

349

50778

            session: self.session.clone(),

350

50778

            initial_viewport: self.initial_viewport.clone(),

351

50778

            dpi: self.dpi,

352

50778

            cr_stack,

353

50778

cr,

354

50778

            user_language: self.user_language.clone(),

355

50778

            drawsub_stack: self.drawsub_stack.clone(),

356

50778

            svg_nesting: self.svg_nesting,

357

50778

            measuring: self.measuring,

358

50778

            testing: self.testing,

359

360

50778

361

362

6907149

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

363

6907149

        &self.session

364

6907149

365

366

33

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

367

33

        &self.user_language

368

33

369

370

1742

    pub fn toplevel_viewport(&self) -> Rect {

371

1742

        *self.initial_viewport.vbox

372

1742

373

374

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

375

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

376

///

377

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

378

    /// to remove it.

379

949022

    pub fn get_transform_for_stacking_ctx(

380

        &self,

381

        stacking_ctx: &StackingContext,

382

        clipping: bool,

383

    ) -> Result<ValidTransform, InternalRenderingError> {

384

949449

        if stacking_ctx.should_isolate() && !clipping {

385

427

            let affines = CompositingAffines::new(

386

427

                *self.get_transform(),

387

427

                self.initial_viewport.transform,

388

427

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

389

427

);

390

391

949449

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

392

        } else {

393

948595

            Ok(self.get_transform())

394

395

949022

396

397

1120

    pub fn svg_nesting(&self) -> SvgNesting {

398

1120

        self.svg_nesting

399

1120

400

401

1084

    pub fn is_measuring(&self) -> bool {

402

1084

        self.measuring

403

1084

404

405

14

    pub fn is_testing(&self) -> bool {

406

14

        self.testing

407

14

408

409

9463589

    pub fn get_transform(&self) -> ValidTransform {

410

9463589

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

411

9463589

        ValidTransform::try_from(t)

412

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

413

9463589

414

415

3514340

    pub fn empty_bbox(&self) -> BoundingBox {

416

3514340

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

417

3514340

418

419

740

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

420

740

        let rect = self.toplevel_viewport();

421

422

740

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

423

424

740

        let (width, height) = self

425

            .initial_viewport

426

            .transform

427

            .transform_distance(viewport_width, viewport_height);

428

429

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

430

        // into the temporary surface.

431

740

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

432

740

433

434

360

    pub fn create_surface_for_toplevel_viewport(

435

        &self,

436

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

437

360

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

438

439

360

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

440

360

441

442

380

    fn create_similar_surface_for_toplevel_viewport(

443

        &self,

444

        surface: &cairo::Surface,

445

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

446

380

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

447

448

380

        Ok(cairo::Surface::create_similar(

449

            surface,

450

380

            cairo::Content::ColorAlpha,

451

w,

452

h,

453

)?)

454

380

455

456

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

457

///

458

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

459

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

460

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

461

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

462

1239

    pub fn push_new_viewport(

463

        &self,

464

        current_viewport: &Viewport,

465

        layout_viewport: &LayoutViewport,

466

    ) -> Option<Viewport> {

467

        let LayoutViewport {

468

1239

            geometry,

469

1239

            vbox,

470

1239

            preserve_aspect_ratio,

471

1239

            overflow,

472

        } = *layout_viewport;

473

474

1239

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

475

145

            clip_to_rectangle(&self.cr, &geometry);

476

477

478

3711

        preserve_aspect_ratio

479

1237

            .viewport_to_viewbox_transform(vbox, &geometry)

480

1239

            .unwrap_or_else(|_e| {

481

2

                match vbox {

482

                    None => unreachable!(

483

                        "viewport_to_viewbox_transform only returns errors when vbox != None"

484

),

485

2

                    Some(v) => {

486

2

                        rsvg_log!(

487

2

                            self.session,

488

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

489

                            v.x0,

490

                            v.y0,

491

                            v.width(),

492

                            v.height()

493

);

494

495

496

2

                None

497

2

})

498

2474

            .map(|t| {

499

1237

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

500

501

1237

                Viewport {

502

1237

                    dpi: self.dpi,

503

1237

                    vbox: vbox.unwrap_or(current_viewport.vbox),

504

1237

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

505

506

1237

})

507

1237

508

509

2006736

    fn clip_to_node(

510

        &mut self,

511

        clip_node: &Option<Node>,

512

        acquired_nodes: &mut AcquiredNodes<'_>,

513

        viewport: &Viewport,

514

        bbox: &BoundingBox,

515

    ) -> Result<(), InternalRenderingError> {

516

2006736

        if clip_node.is_none() {

517

2006607

            return Ok(());

518

519

520

129

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

521

129

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

522

523

129

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

524

127

            let cascaded = CascadedValues::new_from_node(node);

525

127

            let values = cascaded.get();

526

527

43

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

528

2006779

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

529

530

42

            let orig_transform = self.get_transform();

531

42

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

532

533

168

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

534

126

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

535

126

            }) {

536

42

                child.draw(

537

                    acquired_nodes,

538

42

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

539

                    viewport,

540

                    self,

541

                    true,

542

42

)?;

543

42

544

545

42

            self.cr.clip();

546

547

42

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

548

43

549

550

44

        Ok(())

551

2006652

552

553

60

    fn generate_cairo_mask(

554

        &mut self,

555

        mask_node: &Node,

556

        viewport: &Viewport,

557

        transform: Transform,

558

        bbox: &BoundingBox,

559

        acquired_nodes: &mut AcquiredNodes<'_>,

560

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

561

60

        if bbox.rect.is_none() {

562

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

563

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

564

1

            return Ok(None);

565

566

567

59

        let _mask_acquired = match acquired_nodes.acquire_ref(mask_node) {

568

59

            Ok(n) => n,

569

570

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

571

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

572

                return Ok(None);

573

574

575

            _ => unreachable!(),

576

59

};

577

578

59

        let mask_element = mask_node.borrow_element();

579

59

        let mask = borrow_element_as!(mask_node, Mask);

580

581

59

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

582

583

59

        let cascaded = CascadedValues::new_from_node(mask_node);

584

59

        let values = cascaded.get();

585

586

59

        let mask_units = mask.get_units();

587

588

        let mask_rect = {

589

59

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

590

59

            mask.get_rect(&params)

591

};

592

593

59

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

594

59

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

595

596

59

        let mask_content_surface = self.create_surface_for_toplevel_viewport()?;

597

598

        // Use a scope because mask_cr needs to release the

599

        // reference to the surface before we access the pixels

600

601

59

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

602

59

            mask_cr.set_matrix(transform_for_mask.into());

603

604

59

            let bbtransform = Transform::new_unchecked(

605

59

                bbox_rect.width(),

606

                0.0,

607

                0.0,

608

59

                bbox_rect.height(),

609

59

                bbox_rect.x0,

610

59

                bbox_rect.y0,

611

);

612

613

59

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

614

10

                bbtransform.transform_rect(&mask_rect)

615

            } else {

616

49

                mask_rect

617

};

618

619

59

            clip_to_rectangle(&mask_cr, &clip_rect);

620

621

59

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

622

5

                if bbox_rect.is_empty() {

623

1

                    return Ok(None);

624

625

64

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

626

627

628

58

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

629

630

58

            let mut mask_draw_ctx = self.nested(mask_cr);

631

632

58

            let stacking_ctx = StackingContext::new(

633

58

                self.session(),

634

                acquired_nodes,

635

58

                &mask_element,

636

58

                Transform::identity(),

637

58

                None,

638

                values,

639

);

640

641

58

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

642

643

58

            let res = mask_draw_ctx.with_discrete_layer(

644

                &stacking_ctx,

645

                acquired_nodes,

646

                &mask_viewport,

647

58

                None,

648

                false,

649

116

                &mut |an, dc, new_viewport| {

650

58

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

651

58

},

652

58

);

653

654

58

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

655

656

58

            res?;

657

59

658

659

58

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

660

661

58

        let mask_result = match values.mask_type() {

662

57

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

663

1

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

664

};

665

666

58

        let mask = mask_result.into_image_surface()?;

667

668

58

        Ok(Some(mask))

669

60

670

671

2005396

    pub fn with_discrete_layer(

672

        &mut self,

673

        stacking_ctx: &StackingContext,

674

        acquired_nodes: &mut AcquiredNodes<'_>,

675

        viewport: &Viewport,

676

        layout_viewport: Option<LayoutViewport>,

677

        clipping: bool,

678

        draw_fn: &mut dyn FnMut(

679

            &mut AcquiredNodes<'_>,

680

            &mut DrawingCtx,

681

            &Viewport,

682

        ) -> Result<BoundingBox, InternalRenderingError>,

683

    ) -> Result<BoundingBox, InternalRenderingError> {

684

2005396

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

685

686

2005395

        let orig_transform = self.get_transform();

687

2005395

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

688

689

2005395

        let res = if clipping {

690

40

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

691

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

692

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

693

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

694

//

695

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

696

//

697

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

698

                // at the end of this function with set_matrix.

699

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

700

                    draw_fn(acquired_nodes, self, &new_viewport)

701

                } else {

702

                    Ok(self.empty_bbox())

703

704

            } else {

705

40

                draw_fn(acquired_nodes, self, viewport)

706

707

        } else {

708

4009496

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

709

2004141

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

710

2

                    self.link_tag_begin(link_target);

711

712

713

2004141

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

714

715

2004141

                let affine_at_start = self.get_transform();

716

717

2004141

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

718

184

                    clip_to_rectangle(&self.cr, rect);

719

720

721

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

722

4008282

                self.clip_to_node(

723

2004141

                    &stacking_ctx.clip_in_user_space,

724

2004141

                    acquired_nodes,

725

2004141

                    viewport,

726

2004141

                    &self.empty_bbox(),

727

1

)?;

728

729

2004140

                let should_isolate = stacking_ctx.should_isolate();

730

731

2004140

                let res = if should_isolate {

732

                    // Compute our assortment of affines

733

734

681

                    let affines = CompositingAffines::new(

735

681

                        *affine_at_start,

736

681

                        self.initial_viewport.transform,

737

681

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

738

681

);

739

740

                    // Create temporary surface and its cr

741

742

681

                    let cr = match stacking_ctx.filter {

743

380

                        None => cairo::Context::new(

744

760

                            &self

745

380

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

746

380

)?,

747

                        Some(_) => {

748

301

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

749

301

750

};

751

752

681

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

753

754

681

                    let (source_surface, mut res, bbox) = {

755

681

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

756

757

                        // Draw!

758

759

1362

                        let res = with_saved_cr(&cr, || {

760

681

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

761

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

762

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

763

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

764

//

765

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

766

62

                                if let Some(new_viewport) =

767

62

                                    temporary_draw_ctx.push_new_viewport(viewport, layout_viewport)

768

769

62

                                    draw_fn(acquired_nodes, &mut temporary_draw_ctx, &new_viewport)

770

                                } else {

771

                                    Ok(self.empty_bbox())

772

773

                            } else {

774

619

                                draw_fn(acquired_nodes, &mut temporary_draw_ctx, viewport)

775

776

1362

});

777

778

681

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

779

681

                            *bbox

780

                        } else {

781

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

782

};

783

784

1362

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

785

301

                            let surface_to_filter = SharedImageSurface::copy_from_surface(

786

301

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

787

                                    .unwrap(),

788

301

)?;

789

790

                            let stroke_paint_source =

791

301

                                Rc::new(filter.stroke_paint_source.to_user_space(

792

                                    &bbox.rect,

793

301

                                    viewport,

794

301

                                    &filter.normalize_values,

795

301

));

796

                            let fill_paint_source =

797

301

                                Rc::new(filter.fill_paint_source.to_user_space(

798

                                    &bbox.rect,

799

301

                                    viewport,

800

301

                                    &filter.normalize_values,

801

301

));

802

803

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

804

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

805

                            // for primitive_units.  So, get the corresponding NormalizeParams

806

                            // here and pass them down.

807

301

                            let user_space_params = NormalizeParams::from_values(

808

301

                                &filter.normalize_values,

809

301

                                &viewport.with_units(CoordUnits::UserSpaceOnUse),

810

);

811

812

301

                            let filtered_surface = temporary_draw_ctx

813

                                .run_filters(

814

301

                                    viewport,

815

301

                                    surface_to_filter,

816

                                    filter,

817

301

                                    acquired_nodes,

818

301

                                    &stacking_ctx.element_name,

819

                                    &user_space_params,

820

301

                                    stroke_paint_source,

821

301

                                    fill_paint_source,

822

301

                                    bbox,

823

301

)?

824

                                .into_image_surface()?;

825

826

301

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

827

828

301

                            (generic_surface.clone(), res, bbox)

829

301

                        } else {

830

380

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

831

832

681

};

833

834

                    // Set temporary surface as source

835

836

1362

                    self.cr

837

681

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

838

681

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

839

840

                    // Clip

841

842

1362

                    self.cr.set_matrix(

843

681

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

844

);

845

1362

                    self.clip_to_node(

846

681

                        &stacking_ctx.clip_in_object_space,

847

681

                        acquired_nodes,

848

681

                        viewport,

849

                        &bbox,

850

)?;

851

852

                    // Mask

853

854

681

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

855

120

                        res = res.and_then(|bbox| {

856

240

                            self.generate_cairo_mask(

857

60

                                mask_node,

858

60

                                viewport,

859

60

                                affines.for_temporary_surface,

860

                                &bbox,

861

60

                                acquired_nodes,

862

863

120

                            .and_then(|mask_surf| {

864

60

                                if let Some(surf) = mask_surf {

865

58

                                    self.cr.push_group();

866

867

116

                                    self.cr.set_matrix(

868

58

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

869

);

870

58

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

871

872

118

                                    Ok(self.cr.pop_group_to_source()?)

873

58

                                } else {

874

2

                                    Ok(())

875

876

60

})

877

120

                            .map(|_: ()| bbox)

878

60

});

879

880

881

882

                        // Composite the temporary surface

883

884

1362

                        self.cr

885

681

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

886

681

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

887

888

681

                        if opacity < 1.0 {

889

313

                            self.cr.paint_with_alpha(opacity)?;

890

                        } else {

891

368

                            self.cr.paint()?;

892

893

894

895

681

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

896

681

res

897

2004140

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

898

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

899

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

900

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

901

//

902

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

903

//

904

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

905

                    // at the end of this function with set_matrix.

906

1178

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

907

1176

                        draw_fn(acquired_nodes, self, &new_viewport)

908

                    } else {

909

2

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

910

2

                        Ok(self.empty_bbox())

911

912

                } else {

913

2002281

                    draw_fn(acquired_nodes, self, viewport)

914

};

915

916

2004140

                if stacking_ctx.link_target.is_some() {

917

2

                    self.link_tag_end();

918

919

920

2004140

res

921

2004141

})

922

2005355

};

923

924

2005395

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

925

2005395

res

926

2005396

927

928

    /// Run the drawing function with the specified opacity

929

50026

    fn with_alpha(

930

        &mut self,

931

        opacity: UnitInterval,

932

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

933

    ) -> Result<BoundingBox, InternalRenderingError> {

934

50026

        let res;

935

50026

        let UnitInterval(o) = opacity;

936

100051

        if o < 1.0 {

937

1

            self.cr.push_group();

938

1

            res = draw_fn(self);

939

1

            self.cr.pop_group_to_source()?;

940

50027

            self.cr.paint_with_alpha(o)?;

941

        } else {

942

50025

            res = draw_fn(self);

943

944

945

50026

res

946

50026

947

948

    /// Start a Cairo tag for PDF links

949

6

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

950

6

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

951

952

6

        let cr = self.cr.clone();

953

6

        cr.tag_begin(CAIRO_TAG_LINK, &attributes);

954

6

955

956

    /// End a Cairo tag for PDF links

957

6

    fn link_tag_end(&mut self) {

958

6

        self.cr.tag_end(CAIRO_TAG_LINK);

959

6

960

961

301

    fn run_filters(

962

        &mut self,

963

        viewport: &Viewport,

964

        surface_to_filter: SharedImageSurface,

965

        filter: &Filter,

966

        acquired_nodes: &mut AcquiredNodes<'_>,

967

        node_name: &str,

968

        user_space_params: &NormalizeParams,

969

        stroke_paint_source: Rc<UserSpacePaintSource>,

970

        fill_paint_source: Rc<UserSpacePaintSource>,

971

        node_bbox: BoundingBox,

972

    ) -> Result<SharedImageSurface, InternalRenderingError> {

973

301

        let session = self.session();

974

975

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

976

//

977

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

978

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

979

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

980

//

981

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

982

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

983

301

        let filter_specs = filter

984

            .filter_list

985

            .iter()

986

605

            .map(|filter_value| {

987

304

                filter_value.to_filter_spec(

988

304

                    acquired_nodes,

989

304

                    user_space_params,

990

304

                    filter.current_color,

991

304

                    viewport,

992

304

                    session,

993

304

                    node_name,

994

995

304

})

996

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

997

998

301

        match filter_specs {

999

298

            Ok(specs) => {

1000

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

1001

                // the final result is our return value.

1002

597

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

1003

299

                    filters::render(

1004

299

                        spec,

1005

299

                        stroke_paint_source.clone(),

1006

299

                        fill_paint_source.clone(),

1007

299

                        surface,

1008

299

                        acquired_nodes,

1009

299

                        self,

1010

299

                        *self.get_transform(),

1011

299

                        node_bbox,

1012

299

1013

299

})

1014

298

1015

1016

3

            Err(e) => {

1017

3

                rsvg_log!(

1018

3

                    self.session,

1019

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

1020

                    node_name,

1021

1022

);

1023

                // just return the original surface without filtering it

1024

3

                Ok(surface_to_filter)

1025

1026

1027

301

1028

1029

167

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

1030

167

        let g = match gradient.variant {

1031

128

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

1032

128

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

1033

128

1034

1035

            GradientVariant::Radial {

1036

39

cx,

1037

39

cy,

1038

39

r,

1039

39

fx,

1040

39

fy,

1041

39

fr,

1042

39

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

1043

};

1044

1045

167

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

1046

163

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

1047

1048

614

        for stop in &gradient.stops {

1049

453

            let UnitInterval(stop_offset) = stop.offset;

1050

1051

453

            let rgba = color_to_rgba(&stop.color);

1052

1053

451

            g.add_color_stop_rgba(

1054

                stop_offset,

1055

452

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

1056

451

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

1057

451

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

1058

451

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

1059

);

1060

1061

1062

329

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

1063

163

1064

1065

500033

    fn set_pattern(

1066

        &mut self,

1067

        pattern: &UserSpacePattern,

1068

        acquired_nodes: &mut AcquiredNodes<'_>,

1069

    ) -> Result<bool, InternalRenderingError> {

1070

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

1071

500033

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

1072

9

            return Ok(false);

1073

1074

1075

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

1076

500024

        let pattern_node_acquired = match pattern.acquire_pattern_node(acquired_nodes) {

1077

500024

            Ok(n) => n,

1078

1079

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

1080

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

1081

                return Ok(false);

1082

1083

1084

            _ => unreachable!(),

1085

500024

};

1086

1087

500024

        let pattern_node = pattern_node_acquired.get();

1088

1089

500024

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

1090

1091

500024

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

1092

500024

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

1093

1094

500024

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

1095

500024

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

1096

1097

500024

        if pw < 1 || ph < 1 {

1098

449998

            return Ok(false);

1099

1100

1101

50026

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

1102

50026

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

1103

1104

        // Apply the pattern transform

1105

100029

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

1106

23

            (pattern.coord_transform, pattern.content_transform)

1107

        } else {

1108

50003

1109

100006

                pattern

1110

                    .coord_transform

1111

50003

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

1112

50003

                pattern.content_transform.post_scale(scwscale, schscale),

1113

1114

};

1115

1116

        // Draw to another surface

1117

50026

        let surface = self

1118

.cr

1119

            .target()

1120

100052

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

1121

1122

50026

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

1123

1124

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

1125

1126

50026

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

1127

50026

        cr_pattern.set_matrix(transform.into());

1128

1129

        // Draw everything

1130

1131

1132

50026

            let mut pattern_draw_ctx = self.nested(cr_pattern);

1133

1134

50026

            let pattern_viewport = Viewport {

1135

50026

                dpi: self.dpi,

1136

50026

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

1137

50026

                transform: *transform,

1138

};

1139

1140

50026

            pattern_draw_ctx

1141

100052

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

1142

50026

                    let pattern_cascaded = CascadedValues::new_from_node(pattern_node);

1143

50026

                    let pattern_values = pattern_cascaded.get();

1144

1145

50026

                    let elt = pattern_node.borrow_element();

1146

1147

50026

                    let stacking_ctx = StackingContext::new(

1148

50026

                        self.session(),

1149

50026

                        acquired_nodes,

1150

50026

                        &elt,

1151

50026

                        Transform::identity(),

1152

50026

                        None,

1153

                        pattern_values,

1154

);

1155

1156

50026

                    dc.with_discrete_layer(

1157

                        &stacking_ctx,

1158

50026

                        acquired_nodes,

1159

50026

                        &pattern_viewport,

1160

50026

                        None,

1161

                        false,

1162

100052

                        &mut |an, dc, new_viewport| {

1163

100052

                            pattern_node.draw_children(

1164

an,

1165

50026

                                &pattern_cascaded,

1166

                                new_viewport,

1167

dc,

1168

                                false,

1169

1170

50026

},

1171

1172

50026

})

1173

50026

                .map(|_| ())?;

1174

50026

1175

1176

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

1177

50026

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

1178

1179

50026

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

1180

50026

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

1181

50026

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

1182

50026

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

1183

550059

            self.cr.set_source(&pattern)?;

1184

1185

1186

50026

        Ok(true)

1187

500033

1188

1189

1898579

    fn set_paint_source(

1190

        &mut self,

1191

        paint_source: &UserSpacePaintSource,

1192

        acquired_nodes: &mut AcquiredNodes<'_>,

1193

    ) -> Result<bool, InternalRenderingError> {

1194

1898579

        match *paint_source {

1195

163

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

1196

1898579

                self.set_gradient(gradient)?;

1197

163

                Ok(true)

1198

163

1199

500033

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

1200

500033

                if self.set_pattern(pattern, acquired_nodes)? {

1201

50026

                    Ok(true)

1202

450007

                } else if let Some(c) = c {

1203

9

                    set_source_color_on_cairo(&self.cr, c);

1204

9

                    Ok(true)

1205

                } else {

1206

449998

                    Ok(false)

1207

1208

1209

949104

            UserSpacePaintSource::SolidColor(ref c) => {

1210

949104

                set_source_color_on_cairo(&self.cr, c);

1211

949104

                Ok(true)

1212

949104

1213

449279

            UserSpacePaintSource::None => Ok(false),

1214

1215

1898579

1216

1217

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

1218

13

    pub fn get_paint_source_surface(

1219

        &mut self,

1220

        width: i32,

1221

        height: i32,

1222

        acquired_nodes: &mut AcquiredNodes<'_>,

1223

        paint_source: &UserSpacePaintSource,

1224

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1225

13

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

1226

1227

26

        surface.draw(&mut |cr| {

1228

13

            let mut temporary_draw_ctx = self.nested(cr);

1229

1230

            // FIXME: we are ignoring any error

1231

1232

            let had_paint_server =

1233

13

                temporary_draw_ctx.set_paint_source(paint_source, acquired_nodes)?;

1234

13

            if had_paint_server {

1235

26

                temporary_draw_ctx.cr.paint()?;

1236

1237

1238

13

            Ok(())

1239

13

        })?;

1240

1241

13

        Ok(surface.share()?)

1242

13

1243

1244

948507

    fn stroke(

1245

        &mut self,

1246

        cr: &cairo::Context,

1247

        acquired_nodes: &mut AcquiredNodes<'_>,

1248

        paint_source: &UserSpacePaintSource,

1249

    ) -> Result<(), InternalRenderingError> {

1250

948507

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

1251

948507

        if had_paint_server {

1252

1449654

            cr.stroke_preserve()?;

1253

1254

1255

948507

        Ok(())

1256

948507

1257

1258

948389

    fn fill(

1259

        &mut self,

1260

        cr: &cairo::Context,

1261

        acquired_nodes: &mut AcquiredNodes<'_>,

1262

        paint_source: &UserSpacePaintSource,

1263

    ) -> Result<(), InternalRenderingError> {

1264

948389

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

1265

948389

        if had_paint_server {

1266

1446639

            cr.fill_preserve()?;

1267

1268

1269

948389

        Ok(())

1270

948389

1271

1272

949115

    pub fn draw_layer(

1273

        &mut self,

1274

        layer: &Layer,

1275

        acquired_nodes: &mut AcquiredNodes<'_>,

1276

        clipping: bool,

1277

        viewport: &Viewport,

1278

    ) -> Result<BoundingBox, InternalRenderingError> {

1279

949115

        match &layer.kind {

1280

1896186

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

1281

948093

                shape,

1282

                &layer.stacking_ctx,

1283

                acquired_nodes,

1284

                clipping,

1285

                viewport,

1286

),

1287

1828

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

1288

914

                text,

1289

                &layer.stacking_ctx,

1290

                acquired_nodes,

1291

                clipping,

1292

                viewport,

1293

),

1294

216

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

1295

108

                image,

1296

                &layer.stacking_ctx,

1297

                acquired_nodes,

1298

                clipping,

1299

                viewport,

1300

),

1301

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

1302

                group,

1303

                &layer.stacking_ctx,

1304

                acquired_nodes,

1305

                clipping,

1306

                viewport,

1307

),

1308

1309

949115

1310

1311

948029

    fn draw_shape(

1312

        &mut self,

1313

        shape: &Shape,

1314

        stacking_ctx: &StackingContext,

1315

        acquired_nodes: &mut AcquiredNodes<'_>,

1316

        clipping: bool,

1317

        viewport: &Viewport,

1318

    ) -> Result<BoundingBox, InternalRenderingError> {

1319

948029

        if shape.extents.is_none() {

1320

18

            return Ok(self.empty_bbox());

1321

1322

1323

948011

        self.with_discrete_layer(

1324

            stacking_ctx,

1325

            acquired_nodes,

1326

            viewport,

1327

948011

            None,

1328

948011

            clipping,

1329

1910570

            &mut |an, dc, new_viewport| {

1330

962559

                let cr = dc.cr.clone();

1331

1332

962559

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

1333

                let mut path_helper =

1334

948456

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

1335

1336

948370

                if clipping {

1337

39

                    if shape.is_visible {

1338

38

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

1339

38

                        path_helper.set()?;

1340

1341

39

                    return Ok(dc.empty_bbox());

1342

1343

1344

948331

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

1345

1346

948848

                setup_cr_for_stroke(&cr, &shape.stroke);

1347

1348

948101

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

1349

1350

948859

                path_helper.set()?;

1351

948326

                let bbox = compute_stroke_and_fill_box(

1352

                    &cr,

1353

948850

                    &shape.stroke,

1354

948850

                    &shape.stroke_paint,

1355

948850

                    &dc.initial_viewport,

1356

)?;

1357

1358

948508

                if shape.is_visible {

1359

3793882

                    for &target in &shape.paint_order.targets {

1360

                        // fill and stroke operations will preserve the path.

1361

                        // markers operation will clear the path.

1362

2845108

                        match target {

1363

                            PaintTarget::Fill => {

1364

948379

                                path_helper.set()?;

1365

948296

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

1366

1367

1368

                            PaintTarget::Stroke => {

1369

948331

                                path_helper.set()?;

1370

948272

                                let backup_matrix = if shape.stroke.non_scaling {

1371

1

                                    let matrix = cr.matrix();

1372

1

                                    cr.set_matrix(

1373

1

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

1374

                                            .into(),

1375

);

1376

1

                                    Some(matrix)

1377

                                } else {

1378

948270

                                    None

1379

};

1380

1910830

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

1381

948373

                                if let Some(matrix) = backup_matrix {

1382

1

                                    cr.set_matrix(matrix);

1383

1384

1385

1386

948663

                            PaintTarget::Markers => {

1387

948398

                                path_helper.unset();

1388

948387

                                marker::render_markers_for_shape(

1389

949179

                                    shape,

1390

                                    new_viewport,

1391

dc,

1392

an,

1393

949179

                                    clipping,

1394

)?;

1395

1396

1397

1398

1399

1400

952801

                path_helper.unset();

1401

948516

                Ok(bbox)

1402

948555

},

1403

1404

948029

1405

1406

108

    fn paint_surface(

1407

        &mut self,

1408

        surface: &SharedImageSurface,

1409

        width: f64,

1410

        height: f64,

1411

        image_rendering: ImageRendering,

1412

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

1413

108

        let cr = self.cr.clone();

1414

1415

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

1416

//

1417

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

1418

        // transparency outside of the image producing incorrect results.

1419

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

1420

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

1421

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

1422

108

        let ptn = surface.to_cairo_pattern();

1423

108

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

1424

1425

108

        let interpolation = Interpolation::from(image_rendering);

1426

1427

108

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

1428

216

        cr.set_source(&ptn)?;

1429

1430

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

1431

108

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

1432

1433

108

        cr.paint()

1434

108

1435

1436

108

    fn draw_image(

1437

        &mut self,

1438

        image: &Image,

1439

        stacking_ctx: &StackingContext,

1440

        acquired_nodes: &mut AcquiredNodes<'_>,

1441

        clipping: bool,

1442

        viewport: &Viewport,

1443

    ) -> Result<BoundingBox, InternalRenderingError> {

1444

108

        let image_width = image.surface.width();

1445

108

        let image_height = image.surface.height();

1446

108

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

1447

            return Ok(self.empty_bbox());

1448

1449

1450

108

        let image_width = f64::from(image_width);

1451

108

        let image_height = f64::from(image_height);

1452

108

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

1453

1454

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

1455

        // and not by the final computed image bounds.

1456

108

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

1457

1458

108

        let layout_viewport = LayoutViewport {

1459

108

            vbox: Some(vbox),

1460

108

            geometry: image.rect,

1461

108

            preserve_aspect_ratio: image.aspect,

1462

108

            overflow: image.overflow,

1463

};

1464

1465

108

        if image.is_visible {

1466

108

            self.with_discrete_layer(

1467

                stacking_ctx,

1468

                acquired_nodes,

1469

                viewport,

1470

108

                Some(layout_viewport),

1471

                clipping,

1472

216

                &mut |_an, dc, _new_viewport| {

1473

216

                    dc.paint_surface(

1474

108

                        &image.surface,

1475

108

                        image_width,

1476

108

                        image_height,

1477

108

                        image.image_rendering,

1478

)?;

1479

1480

108

                    Ok(bounds)

1481

108

},

1482

1483

        } else {

1484

            Ok(bounds)

1485

1486

108

1487

1488

    fn draw_group(

1489

        &mut self,

1490

        _group: &Group,

1491

        _stacking_ctx: &StackingContext,

1492

        _acquired_nodes: &mut AcquiredNodes<'_>,

1493

        _clipping: bool,

1494

        _viewport: &Viewport,

1495

    ) -> Result<BoundingBox, InternalRenderingError> {

1496

        unimplemented!()

1497

1498

1499

1037

    fn draw_text_span(

1500

        &mut self,

1501

        span: &TextSpan,

1502

        acquired_nodes: &mut AcquiredNodes<'_>,

1503

        clipping: bool,

1504

    ) -> Result<BoundingBox, InternalRenderingError> {

1505

1037

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

1506

1037

        if path.is_empty() {

1507

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

1508

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

1509

            // empty rectangle.

1510

59

            return Ok(self.empty_bbox());

1511

1512

1513

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

1514

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

1515

        // viewers.

1516

978

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

1517

1518

1956

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

1519

1956

            self.cr

1520

978

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

1521

1522

978

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

1523

1524

978

            if clipping {

1525

1

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

1526

1

                return Ok(self.empty_bbox());

1527

1528

1529

977

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

1530

977

            let bbox = compute_stroke_and_fill_box(

1531

977

                &self.cr,

1532

977

                &span.stroke,

1533

977

                &span.stroke_paint,

1534

977

                &self.initial_viewport,

1535

)?;

1536

977

            self.cr.new_path();

1537

1538

977

            if span.is_visible {

1539

967

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

1540

4

                    self.link_tag_begin(link_target);

1541

1542

1543

3867

                for &target in &span.paint_order.targets {

1544

2900

                    match target {

1545

                        PaintTarget::Fill => {

1546

                            let had_paint_server =

1547

967

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

1548

1549

967

                            if had_paint_server {

1550

964

                                if can_use_text_as_path {

1551

960

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

1552

960

                                    self.cr.fill()?;

1553

960

                                    self.cr.new_path();

1554

                                } else {

1555

4

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

1556

1557

4

                                    let matrix = self.cr.matrix();

1558

1559

4

                                    let rotation_from_gravity = span.gravity.to_rotation();

1560

4

                                    if !rotation_from_gravity.approx_eq_cairo(0.0) {

1561

                                        self.cr.rotate(-rotation_from_gravity);

1562

1563

1564

4

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

1565

4

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

1566

1567

4

                                    self.cr.set_matrix(matrix);

1568

1569

1570

1571

1572

                        PaintTarget::Stroke => {

1573

                            let had_paint_server =

1574

967

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

1575

1576

967

                            if had_paint_server {

1577

35

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

1578

35

                                self.cr.stroke()?;

1579

35

                                self.cr.new_path();

1580

1581

1582

1583

                        PaintTarget::Markers => {}

1584

1585

1586

1587

967

                if span.link_target.is_some() {

1588

4

                    self.link_tag_end();

1589

1590

1591

1592

977

            Ok(bbox)

1593

978

})

1594

1037

1595

1596

914

    fn draw_text(

1597

        &mut self,

1598

        text: &Text,

1599

        stacking_ctx: &StackingContext,

1600

        acquired_nodes: &mut AcquiredNodes<'_>,

1601

        clipping: bool,

1602

        viewport: &Viewport,

1603

    ) -> Result<BoundingBox, InternalRenderingError> {

1604

914

        self.with_discrete_layer(

1605

            stacking_ctx,

1606

            acquired_nodes,

1607

            viewport,

1608

914

            None,

1609

914

            clipping,

1610

1828

            &mut |an, dc, _new_viewport| {

1611

914

                let mut bbox = dc.empty_bbox();

1612

1613

1951

                for span in &text.spans {

1614

1037

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

1615

1037

                    bbox.insert(&span_bbox);

1616

1617

1618

914

                Ok(bbox)

1619

914

},

1620

1621

914

1622

1623

10

    pub fn get_snapshot(

1624

        &self,

1625

        width: i32,

1626

        height: i32,

1627

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1628

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

1629

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

1630

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

1631

//

1632

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

1633

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

1634

//

1635

        // Deprecation:

1636

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

1637

//

1638

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

1639

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

1640

//

1641

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

1642

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

1643

10

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

1644

1645

20

        surface.draw(&mut |cr| {

1646

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

1647

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

1648

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

1649

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

1650

22

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

1651

12

                let affines = CompositingAffines::new(

1652

12

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

1653

12

                    self.initial_viewport.transform,

1654

                    depth,

1655

);

1656

1657

12

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

1658

12

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

1659

22

                cr.paint()?;

1660

1661

1662

10

            Ok(())

1663

10

        })?;

1664

1665

10

        Ok(surface.share()?)

1666

10

1667

1668

25

    pub fn draw_node_to_surface(

1669

        &mut self,

1670

        node: &Node,

1671

        acquired_nodes: &mut AcquiredNodes<'_>,

1672

        cascaded: &CascadedValues<'_>,

1673

        affine: Transform,

1674

        width: i32,

1675

        height: i32,

1676

    ) -> Result<SharedImageSurface, InternalRenderingError> {

1677

25

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

1678

1679

25

        let save_cr = self.cr.clone();

1680

1681

1682

25

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

1683

50

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

1684

1685

25

            self.cr = cr;

1686

25

            let viewport = Viewport {

1687

25

                dpi: self.dpi,

1688

                transform: affine,

1689

25

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

1690

};

1691

1692

25

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

1693

25

1694

1695

25

        self.cr = save_cr;

1696

1697

25

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

1698

25

1699

1700

1459955

    pub fn draw_node_from_stack(

1701

        &mut self,

1702

        node: &Node,

1703

        acquired_nodes: &mut AcquiredNodes<'_>,

1704

        cascaded: &CascadedValues<'_>,

1705

        viewport: &Viewport,

1706

        clipping: bool,

1707

    ) -> Result<BoundingBox, InternalRenderingError> {

1708

1459955

        let stack_top = self.drawsub_stack.pop();

1709

1710

1459955

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

1711

2898

            top == node

1712

        } else {

1713

1457057

            true

1714

};

1715

1716

1460372

        let res = if draw {

1717

1458282

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

1718

        } else {

1719

1045

            Ok(self.empty_bbox())

1720

};

1721

1722

1458699

        if let Some(top) = stack_top {

1723

2271

            self.drawsub_stack.push(top);

1724

1725

1726

1458699

res

1727

1458699

1728

1729

500185

    pub fn draw_from_use_node(

1730

        &mut self,

1731

        node: &Node,

1732

        acquired_nodes: &mut AcquiredNodes<'_>,

1733

        values: &ComputedValues,

1734

        use_rect: Rect,

1735

        link: &NodeId,

1736

        clipping: bool,

1737

        viewport: &Viewport,

1738

        fill_paint: Rc<PaintSource>,

1739

        stroke_paint: Rc<PaintSource>,

1740

    ) -> Result<BoundingBox, InternalRenderingError> {

1741

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

1742

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

1743

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

1744

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

1745

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

1746

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

1747

        // references can be caught.

1748

500185

        let _self_acquired = match acquired_nodes.acquire_ref(node) {

1749

500161

            Ok(n) => n,

1750

1751

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

1752

4

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

1753

4

                return Ok(self.empty_bbox());

1754

1755

1756

            _ => unreachable!(),

1757

500165

};

1758

1759

500161

        let acquired = match acquired_nodes.acquire(link) {

1760

500178

            Ok(acquired) => acquired,

1761

1762

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

1763

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

1764

                return Ok(self.empty_bbox());

1765

1766

1767

            Err(AcquireError::MaxReferencesExceeded) => {

1768

1

                return Err(InternalRenderingError::LimitExceeded(

1769

1

                    ImplementationLimit::TooManyReferencedElements,

1770

));

1771

1772

1773

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

1774

1775

4

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

1776

4

                rsvg_log!(

1777

4

                    self.session,

1778

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

1779

                    node,

1780

                    node_id

1781

);

1782

4

                return Ok(self.empty_bbox());

1783

4

1784

5

};

1785

1786

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

1787

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

1788

500178

        if use_rect.is_empty() {

1789

            return Ok(self.empty_bbox());

1790

1791

1792

500156

        let child = acquired.get();

1793

1794

500156

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

1795

1

            return Ok(self.empty_bbox());

1796

1797

1798

500155

        let orig_transform = self.get_transform();

1799

1800

1000310

        self.cr

1801

1000340

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

1802

1803

500155

        let use_element = node.borrow_element();

1804

1805

500155

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

1806

9

            let symbol = borrow_element_as!(child, Symbol);

1807

9

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

1808

500155

        } else if is_element_of_type!(child, Svg) {

1809

1

            let svg = borrow_element_as!(child, Svg);

1810

1

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

1811

1

        } else {

1812

500145

            None

1813

};

1814

1815

500155

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

1816

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

1817

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

1818

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

1819

1820

10

            let elt = child.borrow_element();

1821

1822

10

            let child_values = elt.get_computed_values();

1823

1824

10

            let stacking_ctx = StackingContext::new(

1825

10

                self.session(),

1826

                acquired_nodes,

1827

10

                &use_element,

1828

10

                Transform::identity(),

1829

10

                None,

1830

                values,

1831

);

1832

1833

10

            let layout_viewport = LayoutViewport {

1834

                vbox,

1835

10

                geometry: use_rect,

1836

                preserve_aspect_ratio,

1837

10

                overflow: child_values.overflow(),

1838

};

1839

1840

10

            self.with_discrete_layer(

1841

                &stacking_ctx,

1842

                acquired_nodes,

1843

                viewport,

1844

10

                Some(layout_viewport),

1845

10

                clipping,

1846

20

                &mut |an, dc, new_viewport| {

1847

20

                    child.draw_children(

1848

an,

1849

10

                        &CascadedValues::new_from_values(

1850

10

                            child,

1851

10

                            values,

1852

10

                            Some(fill_paint.clone()),

1853

10

                            Some(stroke_paint.clone()),

1854

10

),

1855

                        new_viewport,

1856

dc,

1857

10

                        clipping,

1858

1859

10

},

1860

10

1861

10

        } else {

1862

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

1863

1864

500145

            let stacking_ctx = StackingContext::new(

1865

500145

                self.session(),

1866

                acquired_nodes,

1867

500145

                &use_element,

1868

500145

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

1869

500145

                None,

1870

                values,

1871

);

1872

1873

500145

            self.with_discrete_layer(

1874

                &stacking_ctx,

1875

                acquired_nodes,

1876

                viewport,

1877

500145

                None,

1878

500145

                clipping,

1879

1000290

                &mut |an, dc, new_viewport| {

1880

1000290

                    child.draw(

1881

an,

1882

500145

                        &CascadedValues::new_from_values(

1883

500145

                            child,

1884

500145

                            values,

1885

500145

                            Some(fill_paint.clone()),

1886

500145

                            Some(stroke_paint.clone()),

1887

500145

),

1888

                        new_viewport,

1889

dc,

1890

500145

                        clipping,

1891

1892

500145

},

1893

500165

1894

500145

};

1895

1896

500155

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

1897

1898

1000293

        if let Ok(bbox) = res {

1899

500138

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

1900

500138

            res_bbox.insert(&bbox);

1901

500138

            Ok(res_bbox)

1902

        } else {

1903

17

res

1904

1905

500164

1906

1907

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

1908

///

1909

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

1910

914

    pub fn get_font_options(&self) -> FontOptions {

1911

914

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

1912

914

        if self.testing {

1913

869

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

1914

1915

1916

914

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

1917

914

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

1918

1919

914

        FontOptions { options }

1920

914

1921

1922

1923

impl From<ImageRendering> for Interpolation {

1924

174

    fn from(r: ImageRendering) -> Interpolation {

1925

174

        match r {

1926

            ImageRendering::Pixelated

1927

            | ImageRendering::CrispEdges

1928

1

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

1929

1930

            ImageRendering::Smooth

1931

            | ImageRendering::OptimizeQuality

1932

            | ImageRendering::HighQuality

1933

173

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

1934

1935

174

1936

1937

1938

949460

pub fn compute_path_extents(path: &Path) -> Result<Option<Rect>, InternalRenderingError> {

1939

949460

    if path.is_empty() {

1940

18

        return Ok(None);

1941

1942

1943

949442

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

1944

949442

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

1945

1946

1898734

    path.to_cairo(&cr, false)?;

1947

947977

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

1948

1949

947860

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

1950

948684

1951

1952

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

1953

1039

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

1954

1039

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

1955

1039

    let context = font_map.create_context();

1956

1957

1039

    context.set_round_glyph_positions(false);

1958

1959

1039

    let pango_matrix = PangoMatrix {

1960

1039

        xx: transform.xx,

1961

1039

        xy: transform.xy,

1962

1039

        yx: transform.yx,

1963

1039

        yy: transform.yy,

1964

1039

        x0: transform.x0,

1965

1039

        y0: transform.y0,

1966

};

1967

1968

1039

    let pango_matrix_ptr: *const PangoMatrix = &pango_matrix;

1969

1970

1039

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

1971

1039

    context.set_matrix(Some(&matrix));

1972

1973

1040

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

1974

1975

    // Pango says this about pango_cairo_context_set_resolution():

1976

//

1977

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

1978

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

1979

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

1980

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

1981

//

1982

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

1983

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

1984

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

1985

    // to the size values we give it.

1986

//

1987

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

1988

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

1989

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

1990

    // code.

1991

1039

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

1992

1993

1037

    context

1994

1037

1995

1996

949136

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

1997

949136

    let rgba = color_to_rgba(color);

1998

1999

949136

    cr.set_source_rgba(

2000

949136

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

2001

949136

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

2002

949136

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

2003

949136

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

2004

);

2005

949136

2006

2007

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

2008

/// Does not clear the current path first.

2009

1037

fn pango_layout_to_cairo(

2010

    x: f64,

2011

    y: f64,

2012

    layout: &pango::Layout,

2013

    gravity: pango::Gravity,

2014

    cr: &cairo::Context,

2015

) {

2016

1037

    let rotation_from_gravity = gravity.to_rotation();

2017

1037

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

2018

        Some(-rotation_from_gravity)

2019

    } else {

2020

1037

        None

2021

};

2022

2023

1037

    cr.move_to(x, y);

2024

2025

1037

    let matrix = cr.matrix();

2026

1037

    if let Some(rot) = rotation {

2027

        cr.rotate(rot);

2028

2029

2030

1037

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

2031

1037

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

2032

1037

    cr.set_matrix(matrix);

2033

1037

2034

2035

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

2036

1039

pub fn pango_layout_to_path(

2037

    x: f64,

2038

    y: f64,

2039

    layout: &pango::Layout,

2040

    gravity: pango::Gravity,

2041

) -> Result<Path, InternalRenderingError> {

2042

1039

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

2043

1039

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

2044

2045

1039

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

2046

2047

1037

    let cairo_path = cr.copy_path()?;

2048

1037

    Ok(Path::from_cairo(cairo_path))

2049

1037

2050

2051

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

2052

43

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

2053

    use ElementData::*;

2054

2055

43

    matches!(

2056

43

        element.element_data,

2057

        Circle(_)

2058

            | Ellipse(_)

2059

            | Line(_)

2060

            | Path(_)

2061

            | Polygon(_)

2062

            | Polyline(_)

2063

            | Rect(_)

2064

            | Text(_)

2065

            | Use(_)

2066

2067

43

2068

2069

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

2070

1

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

2071

    use ElementData::*;

2072

2073

1

    matches!(

2074

1

        element.element_data,

2075

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

2076

2077

1

2078

2079

#[derive(Debug)]

2080

struct CompositingAffines {

2081

    pub outside_temporary_surface: Transform,

2082

    #[allow(unused)]

2083

    pub initial: Transform,

2084

    pub for_temporary_surface: Transform,

2085

    pub compositing: Transform,

2086

    pub for_snapshot: Transform,

2087

2088

2089

impl CompositingAffines {

2090

1120

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

2091

1120

        let is_topmost_temporary_surface = cr_stack_depth == 0;

2092

2093

1120

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

2094

2095

1120

        let outside_temporary_surface = if is_topmost_temporary_surface {

2096

648

            current

2097

        } else {

2098

472

            current.post_transform(&initial_inverse)

2099

};

2100

2101

1120

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

2102

2103

1120

        let for_temporary_surface = if is_topmost_temporary_surface {

2104

648

            current

2105

                .post_transform(&initial_inverse)

2106

                .post_scale(scale_x, scale_y)

2107

        } else {

2108

472

            current

2109

};

2110

2111

1120

        let compositing = if is_topmost_temporary_surface {

2112

648

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

2113

        } else {

2114

472

            Transform::identity()

2115

};

2116

2117

1120

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

2118

2119

1120

        CompositingAffines {

2120

1120

            outside_temporary_surface,

2121

1120

            initial,

2122

1120

            for_temporary_surface,

2123

1120

            compositing,

2124

            for_snapshot,

2125

2126

1120

2127

2128

2129

949110

fn compute_stroke_and_fill_extents(

2130

    cr: &cairo::Context,

2131

    stroke: &Stroke,

2132

    stroke_paint_source: &UserSpacePaintSource,

2133

    initial_viewport: &Viewport,

2134

) -> Result<PathExtents, InternalRenderingError> {

2135

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

2136

    // _rendering_ time speedups, are these rather expensive operations

2137

    // really needed here? */

2138

949110

    let backup_tolerance = cr.tolerance();

2139

949110

    cr.set_tolerance(1.0);

2140

2141

    // Bounding box for fill

2142

//

2143

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

2144

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

2145

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

2146

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

2147

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

2148

2149

949110

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

2150

949110

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

2151

504414

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

2152

    } else {

2153

444696

        None

2154

};

2155

2156

    // Bounding box for stroke

2157

//

2158

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

2159

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

2160

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

2161

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

2162

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

2163

//

2164

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

2165

    // bounding box if so.

2166

2167

1897886

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

2168

948776

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

2169

2170

501181

        let backup_matrix = if stroke.non_scaling {

2171

1

            let matrix = cr.matrix();

2172

949111

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

2173

1

            Some(matrix)

2174

        } else {

2175

501179

            None

2176

};

2177

501180

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

2178

501180

        if let Some(matrix) = backup_matrix {

2179

1

            cr.set_matrix(matrix);

2180

2181

501180

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

2182

    } else {

2183

447930

        None

2184

};

2185

2186

    // objectBoundingBox

2187

2188

949110

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

2189

949110

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

2190

2191

    // restore tolerance

2192

2193

949110

    cr.set_tolerance(backup_tolerance);

2194

2195

949110

    Ok(PathExtents {

2196

        path_only: path_extents,

2197

949110

        fill: fill_extents,

2198

949110

        stroke: stroke_extents,

2199

})

2200

949110

2201

2202

949881

fn compute_stroke_and_fill_box(

2203

    cr: &cairo::Context,

2204

    stroke: &Stroke,

2205

    stroke_paint_source: &UserSpacePaintSource,

2206

    initial_viewport: &Viewport,

2207

) -> Result<BoundingBox, InternalRenderingError> {

2208

    let extents =

2209

949881

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

2210

2211

949881

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

2212

444466

        (None, None) => None,

2213

4235

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

2214

230

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

2215

500950

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

2216

};

2217

2218

949881

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

2219

2220

949881

    if let Some(rect) = extents.path_only {

2221

949719

        bbox = bbox.with_rect(rect);

2222

2223

2224

949881

    if let Some(ink_rect) = ink_rect {

2225

505415

        bbox = bbox.with_ink_rect(ink_rect);

2226

2227

2228

949881

    Ok(bbox)

2229

949881

2230

2231

949226

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

2232

949226

    cr.set_line_width(stroke.width);

2233

949226

    cr.set_miter_limit(stroke.miter_limit.0);

2234

949226

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

2235

949226

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

2236

2237

949226

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

2238

2239

949226

    if total_length > 0.0 {

2240

106

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

2241

    } else {

2242

949120

        cr.set_dash(&[], 0.0);

2243

2244

949226

2245

2246

/// escape quotes and backslashes with backslash

2247

6

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

2248

    let regex = {

2249

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

2250

9

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

2251

};

2252

2253

6

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

2254

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

2255

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

2256

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

2257

            _ => unreachable!(),

2258

2259

})

2260

6

2261

2262

496

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

2263

496

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

2264

496

    cr.clip();

2265

496

2266

2267

impl From<SpreadMethod> for cairo::Extend {

2268

163

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

2269

163

        match s {

2270

157

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

2271

3

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

2272

3

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

2273

2274

163

2275

2276

2277

impl From<StrokeLinejoin> for cairo::LineJoin {

2278

949647

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

2279

949647

        match j {

2280

949514

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

2281

131

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

2282

2

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

2283

2284

949647

2285

2286

2287

impl From<StrokeLinecap> for cairo::LineCap {

2288

949460

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

2289

949460

        match j {

2290

949270

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

2291

158

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

2292

32

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

2293

2294

949460

2295

2296

2297

impl From<MixBlendMode> for cairo::Operator {

2298

681

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

2299

        use cairo::Operator;

2300

2301

681

        match m {

2302

665

            MixBlendMode::Normal => Operator::Over,

2303

1

            MixBlendMode::Multiply => Operator::Multiply,

2304

1

            MixBlendMode::Screen => Operator::Screen,

2305

1

            MixBlendMode::Overlay => Operator::Overlay,

2306

1

            MixBlendMode::Darken => Operator::Darken,

2307

1

            MixBlendMode::Lighten => Operator::Lighten,

2308

1

            MixBlendMode::ColorDodge => Operator::ColorDodge,

2309

1

            MixBlendMode::ColorBurn => Operator::ColorBurn,

2310

1

            MixBlendMode::HardLight => Operator::HardLight,

2311

1

            MixBlendMode::SoftLight => Operator::SoftLight,

2312

2

            MixBlendMode::Difference => Operator::Difference,

2313

1

            MixBlendMode::Exclusion => Operator::Exclusion,

2314

1

            MixBlendMode::Hue => Operator::HslHue,

2315

1

            MixBlendMode::Saturation => Operator::HslSaturation,

2316

1

            MixBlendMode::Color => Operator::HslColor,

2317

1

            MixBlendMode::Luminosity => Operator::HslLuminosity,

2318

2319

681

2320

2321

2322

impl From<ClipRule> for cairo::FillRule {

2323

38

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

2324

38

        match c {

2325

37

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

2326

1

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

2327

2328

38

2329

2330

2331

impl From<FillRule> for cairo::FillRule {

2332

948078

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

2333

948078

        match f {

2334

947914

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

2335

164

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

2336

2337

948078

2338

2339

2340

impl From<ShapeRendering> for cairo::Antialias {

2341

948234

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

2342

948234

        match sr {

2343

948221

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

2344

13

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

2345

2346

948234

2347

2348

2349

impl From<TextRendering> for cairo::Antialias {

2350

978

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

2351

978

        match tr {

2352

            TextRendering::Auto

2353

            | TextRendering::OptimizeLegibility

2354

978

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

2355

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

2356

2357

978

2358

2359

2360

impl From<cairo::Matrix> for Transform {

2361

    #[inline]

2362

10423777

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

2363

10423777

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

2364

10423777

2365

2366

2367

impl From<ValidTransform> for cairo::Matrix {

2368

    #[inline]

2369

6063208

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

2370

6063208

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

2371

6063208

2372

2373

2374

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

2375

///

2376

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

2377

/// what that coordinate system is.

2378

pub struct PathExtents {

2379

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

2380

    pub path_only: Option<Rect>,

2381

2382

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

2383

    pub fill: Option<Rect>,

2384

2385

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

2386

    pub stroke: Option<Rect>,

2387

2388

2389

impl Path {

2390

1898456

    pub fn to_cairo(

2391

        &self,

2392

        cr: &cairo::Context,

2393

        is_square_linecap: bool,

2394

    ) -> Result<(), InternalRenderingError> {

2395

1898456

        assert!(!self.is_empty());

2396

2397

3830879

        for subpath in self.iter_subpath() {

2398

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

2399

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

2400

1932423

            if is_square_linecap {

2401

34

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

2402

34

                if subpath.is_zero_length() {

2403

1898456

                    let stroke_size = 0.002;

2404

2405

1

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

2406

1

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

2407

2408

2409

2410

13838031

            for cmd in subpath.iter_commands() {

2411

11905608

                cmd.to_cairo(cr);

2412

2413

2414

2415

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

2416

//

2417

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

2418

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

2419

//

2420

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

2421

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

2422

2423

1898456

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

2424

1898456

2425

2426

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

2427

1038

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

2428

1038

        let mut builder = PathBuilder::default();

2429

2430

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

2431

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

2432

        // only of MoveTo.

2433

2434

1038

        if !cairo_path_is_only_move_tos(&cairo_path) {

2435

252160

            for segment in cairo_path.iter() {

2436

251184

                match segment {

2437

19591

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

2438

75942

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

2439

137039

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

2440

137039

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

2441

2442

18612

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

2443

2444

2445

2446

2447

1034

        builder.into_path()

2448

1030

2449

2450

2451

1038

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

2452

1038

    path.iter()

2453

2017

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

2454

1038

2455

2456

impl PathCommand {

2457

11908498

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

2458

11908498

        match *self {

2459

1938144

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

2460

7742012

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

2461

290421

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

2462

2588

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

2463

1935333

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

2464

2465

11908498

2466

2467

2468

impl EllipticalArc {

2469

2588

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

2470

2588

        match self.center_parameterization() {

2471

            ArcParameterization::CenterParameters {

2472

2587

                center,

2473

2587

                radii,

2474

2587

                theta1,

2475

2587

                delta_theta,

2476

            } => {

2477

2587

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

2478

2587

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

2479

2480

2587

                let mut theta = theta1;

2481

6603

                for _ in 0..n_segs {

2482

4016

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

2483

                        .to_cairo(cr);

2484

4016

                    theta += d_theta;

2485

2486

2487

            ArcParameterization::LineTo => {

2488

                let (x2, y2) = self.to;

2489

                cr.line_to(x2, y2);

2490

2491

            ArcParameterization::Omit => {}

2492

2493

2588

2494

2495

2496

impl CubicBezierCurve {

2497

294432

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

2498

294432

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

2499

294432

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

2500

294432

2501

2502

2503

#[cfg(test)]

2504

mod tests {

2505

    use super::*;

2506

2507

    #[test]

2508

2

    fn rsvg_path_from_cairo_path() {

2509

1

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

2510

1

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

2511

2512

1

        cr.move_to(1.0, 2.0);

2513

1

        cr.line_to(3.0, 4.0);

2514

1

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

2515

1

        cr.close_path();

2516

2517

1

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

2518

1

        let path = Path::from_cairo(cairo_path);

2519

2520

2

        assert_eq!(

2521

1

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

2522

1

            vec![

2523

1

                PathCommand::MoveTo(1.0, 2.0),

2524

1

                PathCommand::LineTo(3.0, 4.0),

2525

1

                PathCommand::CurveTo(CubicBezierCurve {

2526

1

                    pt1: (5.0, 6.0),

2527

1

                    pt2: (7.0, 8.0),

2528

1

                    to: (9.0, 10.0),

2529

}),

2530

1

                PathCommand::ClosePath,

2531

1

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

2532

],

2533

);

2534

2

2535