Grcov report - cairo-svg-glyph-render.c

1

/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */

2

/* cairo - a vector graphics library with display and print output

3

4

 * Copyright © 2022 Adrian Johnson

5

6

 * This library is free software; you can redistribute it and/or

7

 * modify it either under the terms of the GNU Lesser General Public

8

 * License version 2.1 as published by the Free Software Foundation

9

 * (the "LGPL") or, at your option, under the terms of the Mozilla

10

 * Public License Version 1.1 (the "MPL"). If you do not alter this

11

 * notice, a recipient may use your version of this file under either

12

 * the MPL or the LGPL.

13

14

 * You should have received a copy of the LGPL along with this library

15

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

16

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

17

 * You should have received a copy of the MPL along with this library

18

 * in the file COPYING-MPL-1.1

19

20

 * The contents of this file are subject to the Mozilla Public License

21

 * Version 1.1 (the "License"); you may not use this file except in

22

 * compliance with the License. You may obtain a copy of the License at

23

 * http://www.mozilla.org/MPL/

24

25

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

26

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

27

 * the specific language governing rights and limitations.

28

29

 * The Original Code is the cairo graphics library.

30

31

 * The Initial Developer of the Original Code is Adrian Johnson.

32

33

 * Contributor(s):

34

 *	Adrian Johnson <ajohnson@redneon.com>

35

*/

36

37

#include "cairoint.h"

38

#include "cairo-array-private.h"

39

#include "cairo-ft-private.h"

40

#include "cairo-pattern-private.h"

41

#include "cairo-scaled-font-subsets-private.h"

42

43

#include <stdarg.h>

44

#include <stdio.h>

45

#include <string.h>

46

47

#if HAVE_FT_SVG_DOCUMENT

48

49

#include <ft2build.h>

50

#include FT_COLOR_H

51

52

/* #define SVG_RENDER_PRINT_FUNCTIONS 1 */

53

54

#define WHITE_SPACE_CHARS " \n\r\t\v\f"

55

56

typedef struct {

57

    const char *name;

58

    int red;

59

    int green;

60

    int blue;

61

} color_name_t;

62

63

/* Must be sorted */

64

static color_name_t color_names[] = {

65

    { "aliceblue", 240, 248, 255 },

66

    { "antiquewhite", 250, 235, 215 },

67

    { "aqua",  0, 255, 255 },

68

    { "aquamarine", 127, 255, 212 },

69

    { "azure", 240, 255, 255 },

70

    { "beige", 245, 245, 220 },

71

    { "bisque", 255, 228, 196 },

72

    { "black",  0, 0, 0 },

73

    { "blanchedalmond", 255, 235, 205 },

74

    { "blue",  0, 0, 255 },

75

    { "blueviolet", 138, 43, 226 },

76

    { "brown", 165, 42, 42 },

77

    { "burlywood", 222, 184, 135 },

78

    { "cadetblue",  95, 158, 160 },

79

    { "chartreuse", 127, 255, 0 },

80

    { "chocolate", 210, 105, 30 },

81

    { "coral", 255, 127, 80 },

82

    { "cornflowerblue", 100, 149, 237 },

83

    { "cornsilk", 255, 248, 220 },

84

    { "crimson", 220, 20, 60 },

85

    { "cyan",  0, 255, 255 },

86

    { "darkblue",  0, 0, 139 },

87

    { "darkcyan",  0, 139, 139 },

88

    { "darkgoldenrod", 184, 134, 11 },

89

    { "darkgray", 169, 169, 169 },

90

    { "darkgreen",  0, 100, 0 },

91

    { "darkgrey", 169, 169, 169 },

92

    { "darkkhaki", 189, 183, 107 },

93

    { "darkmagenta", 139, 0, 139 },

94

    { "darkolivegreen",  85, 107, 47 },

95

    { "darkorange", 255, 140, 0 },

96

    { "darkorchid", 153, 50, 204 },

97

    { "darkred", 139, 0, 0 },

98

    { "darksalmon", 233, 150, 122 },

99

    { "darkseagreen", 143, 188, 143 },

100

    { "darkslateblue",  72, 61, 139 },

101

    { "darkslategray",  47, 79, 79 },

102

    { "darkslategrey",  47, 79, 79 },

103

    { "darkturquoise",  0, 206, 209 },

104

    { "darkviolet", 148, 0, 211 },

105

    { "deeppink", 255, 20, 147 },

106

    { "deepskyblue",  0, 191, 255 },

107

    { "dimgray", 105, 105, 105 },

108

    { "dimgrey", 105, 105, 105 },

109

    { "dodgerblue",  30, 144, 255 },

110

    { "firebrick", 178, 34, 34 },

111

    { "floralwhite", 255, 250, 240 },

112

    { "forestgreen",  34, 139, 34 },

113

    { "fuchsia", 255, 0, 255 },

114

    { "gainsboro", 220, 220, 220 },

115

    { "ghostwhite", 248, 248, 255 },

116

    { "gold", 255, 215, 0 },

117

    { "goldenrod", 218, 165, 32 },

118

    { "gray", 128, 128, 128 },

119

    { "green",  0, 128, 0 },

120

    { "greenyellow", 173, 255, 47 },

121

    { "grey", 128, 128, 128 },

122

    { "honeydew", 240, 255, 240 },

123

    { "hotpink", 255, 105, 180 },

124

    { "indianred", 205, 92, 92 },

125

    { "indigo",  75, 0, 130 },

126

    { "ivory", 255, 255, 240 },

127

    { "khaki", 240, 230, 140 },

128

    { "lavender", 230, 230, 250 },

129

    { "lavenderblush", 255, 240, 245 },

130

    { "lawngreen", 124, 252, 0 },

131

    { "lemonchiffon", 255, 250, 205 },

132

    { "lightblue", 173, 216, 230 },

133

    { "lightcoral", 240, 128, 128 },

134

    { "lightcyan", 224, 255, 255 },

135

    { "lightgoldenrodyellow", 250, 250, 210 },

136

    { "lightgray", 211, 211, 211 },

137

    { "lightgreen", 144, 238, 144 },

138

    { "lightgrey", 211, 211, 211 },

139

    { "lightpink", 255, 182, 193 },

140

    { "lightsalmon", 255, 160, 122 },

141

    { "lightseagreen",  32, 178, 170 },

142

    { "lightskyblue", 135, 206, 250 },

143

    { "lightslategray", 119, 136, 153 },

144

    { "lightslategrey", 119, 136, 153 },

145

    { "lightsteelblue", 176, 196, 222 },

146

    { "lightyellow", 255, 255, 224 },

147

    { "lime",  0, 255, 0 },

148

    { "limegreen",  50, 205, 50 },

149

    { "linen", 250, 240, 230 },

150

    { "magenta", 255, 0, 255 },

151

    { "maroon", 128, 0, 0 },

152

    { "mediumaquamarine", 102, 205, 170 },

153

    { "mediumblue",  0, 0, 205 },

154

    { "mediumorchid", 186, 85, 211 },

155

    { "mediumpurple", 147, 112, 219 },

156

    { "mediumseagreen",  60, 179, 113 },

157

    { "mediumslateblue", 123, 104, 238 },

158

    { "mediumspringgreen",  0, 250, 154 },

159

    { "mediumturquoise",  72, 209, 204 },

160

    { "mediumvioletred", 199, 21, 133 },

161

    { "midnightblue",  25, 25, 112 },

162

    { "mintcream", 245, 255, 250 },

163

    { "mistyrose", 255, 228, 225 },

164

    { "moccasin", 255, 228, 181 },

165

    { "navajowhite", 255, 222, 173 },

166

    { "navy",  0, 0, 128 },

167

    { "oldlace", 253, 245, 230 },

168

    { "olive", 128, 128, 0 },

169

    { "olivedrab", 107, 142, 35 },

170

    { "orange", 255, 165, 0 },

171

    { "orangered", 255, 69, 0 },

172

    { "orchid", 218, 112, 214 },

173

    { "palegoldenrod", 238, 232, 170 },

174

    { "palegreen", 152, 251, 152 },

175

    { "paleturquoise", 175, 238, 238 },

176

    { "palevioletred", 219, 112, 147 },

177

    { "papayawhip", 255, 239, 213 },

178

    { "peachpuff", 255, 218, 185 },

179

    { "peru", 205, 133, 63 },

180

    { "pink", 255, 192, 203 },

181

    { "plum", 221, 160, 221 },

182

    { "powderblue", 176, 224, 230 },

183

    { "purple", 128, 0, 128 },

184

    { "red", 255, 0, 0 },

185

    { "rosybrown", 188, 143, 143 },

186

    { "royalblue",  65, 105, 225 },

187

    { "saddlebrown", 139, 69, 19 },

188

    { "salmon", 250, 128, 114 },

189

    { "sandybrown", 244, 164, 96 },

190

    { "seagreen",  46, 139, 87 },

191

    { "seashell", 255, 245, 238 },

192

    { "sienna", 160, 82, 45 },

193

    { "silver", 192, 192, 192 },

194

    { "skyblue", 135, 206, 235 },

195

    { "slateblue", 106, 90, 205 },

196

    { "slategray", 112, 128, 144 },

197

    { "slategrey", 112, 128, 144 },

198

    { "snow", 255, 250, 250 },

199

    { "springgreen",  0, 255, 127 },

200

    { "steelblue",  70, 130, 180 },

201

    { "tan", 210, 180, 140 },

202

    { "teal",  0, 128, 128 },

203

    { "thistle", 216, 191, 216 },

204

    { "tomato", 255, 99, 71 },

205

    { "turquoise",  64, 224, 208 },

206

    { "violet", 238, 130, 238 },

207

    { "wheat", 245, 222, 179 },

208

    { "white", 255, 255, 255 },

209

    { "whitesmoke", 245, 245, 245 },

210

    { "yellow", 255, 255, 0 },

211

    { "yellowgreen", 154, 205, 50 }

212

};

213

214

typedef struct {

215

    char *name;

216

    char *value;

217

} svg_attribute_t;

218

219

typedef enum {

220

    CONTAINER_ELEMENT,

221

    EMPTY_ELEMENT,

222

    PROCESSING_INSTRUCTION,

223

    DOCTYPE,

224

    CDATA,

225

    COMMENT

226

} tag_type_t;

227

228

#define TOP_ELEMENT_TAG "_top"

229

230

typedef struct _cairo_svg_element {

231

    cairo_hash_entry_t base;

232

    tag_type_t type;

233

    char *tag;

234

    char *id;

235

    cairo_array_t attributes; /* svg_attribute_t */

236

    cairo_array_t children; /* cairo_svg_element_t* */

237

    cairo_array_t  content; /* char */

238

    cairo_pattern_t *pattern; /* defined if a paint server */

239

    struct _cairo_svg_element *next; /* next on element stack */

240

} cairo_svg_element_t;

241

242

typedef struct _cairo_svg_color {

243

    enum { RGB, FOREGROUND } type;

244

    double red;

245

    double green;

246

    double blue;

247

} cairo_svg_color_t;

248

249

typedef struct _cairo_svg_paint {

250

    enum { PAINT_COLOR, PAINT_SERVER, PAINT_NONE } type;

251

    cairo_svg_color_t color;

252

    cairo_svg_element_t *paint_server;

253

} cairo_svg_paint_t;

254

255

typedef enum {

256

    GS_RENDER,

257

    GS_NO_RENDER,

258

    GS_COMPUTE_BBOX,

259

    GS_CLIP

260

} gs_mode_t;

261

262

typedef struct _cairo_svg_graphics_state {

263

    cairo_svg_paint_t fill;

264

    cairo_svg_paint_t stroke;

265

    cairo_svg_color_t color;

266

    double fill_opacity;

267

    double stroke_opacity;

268

    double opacity;

269

    cairo_fill_rule_t fill_rule;

270

    cairo_fill_rule_t clip_rule;

271

    cairo_path_t *clip_path;

272

    char *dash_array;

273

    double dash_offset;

274

    gs_mode_t mode;

275

    struct {

276

        double x;

277

        double y;

278

        double width;

279

        double height;

280

    } bbox;

281

    struct _cairo_svg_graphics_state *next;

282

} cairo_svg_graphics_state_t;

283

284

typedef enum {

285

    BUILD_PATTERN_NONE,

286

    BUILD_PATTERN_LINEAR,

287

    BUILD_PATTERN_RADIAL

288

} build_pattern_t;

289

290

typedef struct _cairo_svg_glyph_render {

291

    cairo_svg_element_t *tree;

292

    cairo_hash_table_t *ids;

293

    cairo_svg_graphics_state_t *graphics_state;

294

    cairo_t *cr;

295

    double units_per_em;

296

    struct {

297

        cairo_svg_element_t *paint_server;

298

        cairo_pattern_t *pattern;

299

        build_pattern_t type;

300

    } build_pattern;

301

    int render_element_tree_depth;

302

    int num_palette_entries;

303

    FT_Color* palette;

304

305

    /* Viewport */

306

    double width;

307

    double height;

308

    cairo_bool_t view_port_set;

309

310

    cairo_pattern_t *foreground_marker;

311

    cairo_pattern_t *foreground_source;

312

    cairo_bool_t foreground_source_used;

313

314

    int debug; /* 0 = quiet, 1 = errors, 2 = warnings, 3 = info */

315

} cairo_svg_glyph_render_t;

316

317

318

#define SVG_RENDER_ERROR 1

319

#define SVG_RENDER_WARNING 2

320

#define SVG_RENDER_INFO 3

321

322

#define print_error(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_ERROR, ##__VA_ARGS__)

323

#define print_warning(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_WARNING, ##__VA_ARGS__)

324

#define print_info(render, ...) cairo_svg_glyph_render_printf(render, SVG_RENDER_INFO, ##__VA_ARGS__)

325

326

static void

327

cairo_svg_glyph_render_printf (cairo_svg_glyph_render_t *svg_render,

328

                               int level,

329

                               const char *fmt, ...) CAIRO_PRINTF_FORMAT (3, 4);

330

331

static void

332

1080

cairo_svg_glyph_render_printf (cairo_svg_glyph_render_t *svg_render,

333

                               int level,

334

                               const char *fmt, ...)

335

336

    va_list ap;

337

338

1080

    if (svg_render->debug >= level ) {

339

        switch (level) {

340

            case SVG_RENDER_ERROR:

341

                printf("ERROR: ");

342

                break;

343

            case SVG_RENDER_WARNING:

344

                printf("WARNING: ");

345

                break;

346

347

	va_start (ap, fmt);

348

	vprintf (fmt, ap);

349

	va_end (ap);

350

	printf ("\n");

351

352

1080

353

354

static cairo_bool_t

355

105471

string_equal (const char *s1, const char *s2)

356

357

105471

    if (s1 && s2)

358

93588

        return strcmp (s1, s2) == 0;

359

360

11883

    if (!s1 && !s2)

361

        return TRUE;

362

363

11883

    return FALSE;

364

365

366

static cairo_bool_t

367

1713

string_match (const char **p, const char *str)

368

369

1713

    if (*p && strncmp (*p, str, strlen (str)) == 0) {

370

810

        *p += strlen (str);

371

810

        return TRUE;

372

373

903

    return FALSE;

374

375

376

static const char *

377

15891

skip_space (const char *p)

378

379

29721

    while (*p && _cairo_isspace (*p))

380

13830

        p++;

381

382

15891

    return p;

383

384

385

/* Skip over character c and and whitespace before or after. Returns

386

 * NULL if c not found. */

387

static const char *

388

435

skip_char (const char *p, char c)

389

390

435

    while (_cairo_isspace (*p))

391

        p++;

392

393

435

    if (*p != c)

394

        return NULL;

395

396

435

    p++;

397

398

669

    while (_cairo_isspace (*p))

399

234

        p++;

400

401

435

    return p;

402

403

404

static int

405

3708

_color_name_compare (const void *a, const void *b)

406

407

3708

    const color_name_t *a_color = a;

408

3708

    const color_name_t *b_color = b;

409

410

3708

    return strcmp (a_color->name, b_color->name);

411

412

413

static void

414

384

init_element_id_key (cairo_svg_element_t *element)

415

416

384

    element->base.hash = _cairo_hash_string (element->id);

417

384

418

419

static cairo_bool_t

420

177

_element_id_equal (const void *key_a, const void *key_b)

421

422

177

    const cairo_svg_element_t *a = key_a;

423

177

    const cairo_svg_element_t *b = key_b;

424

425

177

    return string_equal (a->id, b->id);

426

427

428

/* Find element with the "id" attribute matching id. id may have the

429

 * '#' prefix. It will be stripped before searching.

430

*/

431

static cairo_svg_element_t *

432

177

lookup_element (cairo_svg_glyph_render_t *svg_render, const char *id)

433

434

    cairo_svg_element_t key;

435

436

177

    if (!id || strlen (id) < 1)

437

        return NULL;

438

439

177

    key.id = (char *)(id[0] == '#' ? id + 1 : id);

440

177

    init_element_id_key (&key);

441

177

    return _cairo_hash_table_lookup (svg_render->ids, &key.base);

442

443

444

/* Find element with the "id" attribute matching url where url is of

445

 * the form "url(#id)".

446

*/

447

static cairo_svg_element_t *

448

105

lookup_url_element (cairo_svg_glyph_render_t *svg_render, const char *url)

449

450

105

    const char *p = url;

451

105

    cairo_svg_element_t *element = NULL;

452

453

105

    if (p && string_match (&p, "url")) {

454

105

        p = skip_char (p, '(');

455

105

        if (!p)

456

            return NULL;

457

458

105

        const char *end = strpbrk(p, WHITE_SPACE_CHARS ")");

459

105

        if (end) {

460

105

            char *id = _cairo_strndup (p, end - p);

461

105

            element = lookup_element (svg_render, id);

462

105

            free (id);

463

464

465

105

    return element;

466

467

468

static const char *

469

24237

get_attribute (const cairo_svg_element_t *element, const char *name)

470

471

    svg_attribute_t attr;

472

    int num_elems, i;

473

474

24237

    num_elems = _cairo_array_num_elements (&element->attributes);

475

95838

    for (i = 0; i < num_elems; i++) {

476

74967

	_cairo_array_copy_element (&element->attributes, i, &attr);

477

74967

        if (string_equal (attr.name, name))

478

3366

            return attr.value;

479

480

20871

    return NULL;

481

482

483

static const char *

484

78

get_href_attribute (const cairo_svg_element_t *element)

485

486

    svg_attribute_t attr;

487

    int num_elems, i, len;

488

489

    /* SVG2 requires the href attribute to be "href". Older versions

490

     * used "xlink:href". I have seen at least one font that used an

491

     * alternative name space eg "ns1:href". To keep things simple we

492

     * search for an attribute named "href" or ending in ":href".

493

*/

494

78

    num_elems = _cairo_array_num_elements (&element->attributes);

495

105

    for (i = 0; i < num_elems; i++) {

496

105

	_cairo_array_copy_element (&element->attributes, i, &attr);

497

105

        if (string_equal (attr.name, "href"))

498

            return attr.value;

499

500

105

        len = strlen (attr.name);

501

105

        if (len > 4 && string_equal (attr.name + len - 5, ":href"))

502

78

            return attr.value;

503

504

    return NULL;

505

506

507

/* Get a float attribute or float percentage. If attribute is a

508

 * percentage, the returned value is percentage * scale.  Does not

509

 * modify value if it returns FALSE. This allows value to be set to a

510

 * default before calling get_float_attribute(), then used without

511

 * checking the return value of this function.

512

*/

513

static cairo_bool_t

514

5400

get_float_or_percent_attribute (const cairo_svg_element_t *element,

515

                                const char *name,

516

                                double scale,

517

                                double *value)

518

519

    const char *p;

520

    char *end;

521

    double v;

522

523

5400

    p = get_attribute (element, name);

524

5400

    if (p) {

525

2025

        v = _cairo_strtod (p, &end);

526

2025

        if (end != p) {

527

2025

            *value = v;

528

2025

            if (*end == '%')

529

189

                *value *= scale / 100.0;

530

2025

            return TRUE;

531

532

533

3375

    return FALSE;

534

535

536

/* Does not modify value if it returns FALSE. This allows value to be

537

 * set to a default before calling get_float_attribute(), then used

538

 * without checking the return value of this function.

539

*/

540

static cairo_bool_t

541

3777

get_float_attribute (const cairo_svg_element_t *element, const char *name, double *value)

542

543

    const char *p;

544

    char *end;

545

    double v;

546

547

3777

    p = get_attribute (element, name);

548

3777

    if (p) {

549

186

        v = _cairo_strtod (p, &end);

550

186

        if (end != p) {

551

186

            *value = v;

552

186

            return TRUE;

553

554

555

3591

    return FALSE;

556

557

558

static cairo_fill_rule_t

559

2328

get_fill_rule_attribute (const cairo_svg_element_t *element, const char *name, cairo_fill_rule_t default_value)

560

561

    const char *p;

562

563

2328

    p = get_attribute (element, name);

564

2328

    if (string_equal (p, "nonzero"))

565

6

        return CAIRO_FILL_RULE_WINDING;

566

2322

    else if (string_equal (p, "evenodd"))

567

6

        return CAIRO_FILL_RULE_EVEN_ODD;

568

    else

569

2316

        return default_value;

570

571

572

static void

573

1647

free_elements (cairo_svg_glyph_render_t *svg_render,

574

              cairo_svg_element_t      *element)

575

576

    int num_elems;

577

578

1647

    num_elems = _cairo_array_num_elements (&element->children);

579

3024

    for (int i = 0; i < num_elems; i++) {

580

	cairo_svg_element_t *child;

581

1377

        _cairo_array_copy_element (&element->children, i, &child);

582

1377

	free_elements (svg_render, child);

583

584

1647

    _cairo_array_fini (&element->children);

585

586

1647

    num_elems = _cairo_array_num_elements (&element->attributes);

587

5574

    for (int i = 0; i < num_elems; i++) {

588

3927

	svg_attribute_t *attr = _cairo_array_index (&element->attributes, i);

589

3927

	free (attr->name);

590

3927

	free (attr->value);

591

592

1647

    _cairo_array_fini (&element->attributes);

593

1647

    _cairo_array_fini (&element->content);

594

595

1647

    free (element->tag);

596

597

1647

    if (element->id) {

598

207

        _cairo_hash_table_remove (svg_render->ids, &element->base);

599

207

        free (element->id);

600

601

602

1647

    if (element->pattern)

603

        cairo_pattern_destroy (element->pattern);

604

605

1647

    free (element);

606

1647

607

608

#if SVG_RENDER_PRINT_FUNCTIONS

609

610

static void indent(int level)

611

612

    for (int i = 1; i < level; i++)

613

        printf("  ");

614

615

616

static void

617

print_element (cairo_svg_element_t *element, cairo_bool_t recurse, int level)

618

619

    char *content = strndup (_cairo_array_index_const (&element->content, 0),

620

                             _cairo_array_num_elements (&element->content));

621

622

    indent(level);

623

    if (element->type == COMMENT) {

624

        printf("<!--%s-->\n", content);

625

    } else if (element->type == CDATA) {

626

        printf("<![CDATA[%s]]>\n", content);

627

    } else if (element->type == DOCTYPE) {

628

        printf("<!DOCTYPE%s>\n", content);

629

    } else if (element->type == PROCESSING_INSTRUCTION) {

630

        printf("<?%s?>\n", content);

631

    } else {

632

        cairo_bool_t top_element = string_equal (element->tag, TOP_ELEMENT_TAG);

633

634

        if (!top_element) {

635

            printf("<%s", element->tag);

636

            int num_elems = _cairo_array_num_elements (&element->attributes);

637

            for (int i = 0; i < num_elems; i++) {

638

                svg_attribute_t *attr = _cairo_array_index (&element->attributes, i);

639

                printf(" %s=\"%s\"", attr->name, attr->value);

640

641

            if (num_elems > 0)

642

                printf(" ");

643

644

            if (element->type == EMPTY_ELEMENT)

645

                printf("/>\n");

646

            else

647

                printf(">\n");

648

649

650

        if (element->type == CONTAINER_ELEMENT) {

651

            if (recurse) {

652

                int num_elems = _cairo_array_num_elements (&element->children);

653

                for (int i = 0; i < num_elems; i++) {

654

                    cairo_svg_element_t *child;

655

                    _cairo_array_copy_element (&element->children, i, &child);

656

                    print_element (child, TRUE, level + 1);

657

658

659

            if (!top_element)

660

                printf("</%s>\n", element->tag);

661

662

663

    free (content);

664

665

#endif

666

667

static const char *

668

963

parse_list_of_floats (const char *p,

669

                      int num_required,

670

                      int num_optional,

671

                      cairo_bool_t *have_optional,

672

                      va_list ap)

673

674

    double d;

675

    double *dp;

676

    char *end;

677

963

    const char *q = NULL;

678

963

    int num_found = 0;

679

680

4758

    for (int i = 0; i < num_required + num_optional; i++) {

681

7146

        while (p && (*p == ',' || _cairo_isspace (*p)))

682

3336

            p++;

683

684

3810

        if (!p)

685

            break;

686

687

3810

        d = _cairo_strtod (p, &end);

688

3810

        if (end == p) {

689

15

            p = NULL;

690

15

            break;

691

692

3795

        p = end;

693

3795

        dp = va_arg (ap, double *);

694

3795

        *dp = d;

695

3795

        num_found++;

696

3795

        if (num_found == num_required)

697

963

            q = p;

698

699

700

963

    if (num_optional > 0) {

701

138

        if (num_found == num_required + num_optional) {

702

123

            *have_optional = TRUE;

703

        } else {

704

15

            *have_optional = FALSE;

705

            /* restore pointer to end of required floats */

706

15

            p = q;

707

708

709

710

963

    return p;

711

712

713

static const char *

714

150

get_floats (const char *p,

715

            int num_required,

716

            int num_optional,

717

            cairo_bool_t *have_optional,

718

            ...)

719

720

    va_list ap;

721

722

150

    va_start (ap, have_optional);

723

150

    p = parse_list_of_floats (p, num_required, num_optional, have_optional, ap);

724

150

    va_end (ap);

725

150

    return p;

726

727

728

static const char *

729

813

get_path_params (const char *p, int num_params, ...)

730

731

    va_list ap;

732

733

813

    va_start (ap, num_params);

734

813

    p = parse_list_of_floats (p, num_params, 0, NULL, ap);

735

813

    va_end (ap);

736

813

    return p;

737

738

739

static cairo_bool_t

740

720

get_color (cairo_svg_glyph_render_t *svg_render,

741

           const char               *s,

742

           cairo_svg_color_t        *color)

743

744

    int len, matched;

745

720

    unsigned r = 0, g = 0, b = 0;

746

747

720

    if (!s)

748

        return FALSE;

749

750

720

    len = strlen(s);

751

752

720

    if (string_equal (s, "inherit")) {

753

	return FALSE;

754

1398

    } else if (string_equal (s, "currentColor") ||

755

1356

	       string_equal (s, "context-fill") ||

756

678

	       string_equal (s, "context-stroke"))

757

758

42

	*color = svg_render->graphics_state->color;

759

42

        return TRUE;

760

678

    } else if (len > 0 && s[0] == '#') {

761

27

        if (len == 4) {

762

6

            matched = sscanf (s + 1, "%1x%1x%1x", &r, &g, &b);

763

6

            if (matched == 3) {

764

                /* Each digit is repeated to convert to 6 digits. eg 0x123 -> 0x112233 */

765

6

                color->type = RGB;

766

6

                color->red = 0x11*r/255.0;

767

6

                color->green = 0x11*g/255.0;

768

6

                color->blue = 0x11*b/255.0;

769

6

                return TRUE;

770

771

21

        } else if (len == 7) {

772

21

            matched = sscanf (s + 1, "%2x%2x%2x", &r, &g, &b);

773

21

            if (matched == 3) {

774

21

                color->type = RGB;

775

21

                color->red = r/255.0;

776

21

                color->green = g/255.0;

777

21

                color->blue = b/255.0;

778

21

                return TRUE;

779

780

781

651

    } else if (strncmp (s, "rgb", 3) == 0) {

782

6

        matched = sscanf (s, "rgb ( %u , %u , %u )", &r, &g, &b);

783

6

        if (matched == 3) {

784

6

            color->type = RGB;

785

6

            color->red = r/255.0;

786

6

            color->green = g/255.0;

787

6

            color->blue = b/255.0;

788

6

            return TRUE;

789

790

645

    } else if (strncmp (s, "var", 3) == 0) {

791

        /* CPAL palettes colors. eg "var(--color0, yellow)" */

792

30

        s += 3;

793

30

        s = skip_char (s, '(');

794

30

        if (!string_match (&s, "--color"))

795

            return FALSE;

796

797

        char *end;

798

30

        int entry = strtol (s, &end, 10);

799

30

        if (end == s)

800

            return FALSE;

801

802

30

        if (svg_render->palette && entry >= 0 && entry < svg_render->num_palette_entries) {

803

30

            FT_Color *palette_color = &svg_render->palette[entry];

804

30

            color->type = RGB;

805

30

            color->red = palette_color->red / 255.0;

806

30

            color->green = palette_color->green/ 255.0;

807

30

            color->blue = palette_color->blue / 255.0;

808

30

            return TRUE;

809

        } else {

810

            /* Fallback color */

811

            s = skip_char (end, ',');

812

            if (!s)

813

            return FALSE;

814

815

            end = strpbrk(s, WHITE_SPACE_CHARS ")");

816

            if (!end || end == s)

817

		return FALSE;

818

819

            char *fallback = _cairo_strndup (s, end - s);

820

            cairo_bool_t success = get_color (svg_render, fallback, color);

821

            free (fallback);

822

            return success;

823

824

    } else {

825

        const color_name_t *color_name;

826

        color_name_t color_name_key;

827

828

615

        color_name_key.name = (char *) s;

829

615

        color_name = bsearch (&color_name_key,

830

                              color_names,

831

                              ARRAY_LENGTH (color_names),

832

                              sizeof (color_name_t),

833

                             _color_name_compare);

834

615

        if (color_name) {

835

615

            color->type = RGB;

836

615

            color->red = color_name->red/255.0;

837

615

            color->green = color_name->green/255.0;

838

615

            color->blue = color_name->blue/255.0;

839

615

            return TRUE;

840

841

842

    return FALSE;

843

844

845

static void

846

924

get_paint (cairo_svg_glyph_render_t *svg_render,

847

           const char *p,

848

           cairo_svg_paint_t *paint)

849

850

    cairo_svg_element_t *element;

851

852

924

    if (string_match (&p, "none")) {

853

387

        paint->type = PAINT_NONE;

854

387

        paint->paint_server = NULL;

855

537

    } else if (p && strncmp (p, "url", 3) == 0) {

856

57

        element = lookup_url_element (svg_render, p);

857

57

        if (element) {

858

57

            paint->type = PAINT_SERVER;

859

57

            paint->paint_server = element;

860

861

    } else {

862

480

        if (get_color (svg_render, p, &paint->color)) {

863

480

            paint->type = PAINT_COLOR;

864

480

            paint->paint_server = NULL;

865

866

867

924

868

869

#ifdef SVG_RENDER_PRINT_FUNCTIONS

870

871

static void

872

print_color (cairo_svg_color_t *color)

873

874

    switch (color->type) {

875

        case FOREGROUND_COLOR:

876

            printf("foreground");

877

            break;

878

        case RGB:

879

            printf("#%02x%02x%02x",

880

                   (int)(color->red*255),

881

                   (int)(color->red*255),

882

                   (int)(color->red*255));

883

            break;

884

885

886

887

static void

888

print_paint (cairo_svg_paint_t *paint)

889

890

    printf("Paint: ");

891

    switch (paint->type) {

892

        case PAINT_COLOR:

893

            printf("color: ");

894

            print_color (&paint->color);

895

            break;

896

        case PAINT_SERVER:

897

            printf("server: %s", paint->paint_server->tag);

898

            break;

899

        case PAINT_NONE:

900

            printf("none");

901

            break;

902

903

    printf("\n");

904

905

906

#endif

907

908

static void

909

parse_error (cairo_svg_glyph_render_t *svg_render,

910

             const char *string,

911

             const char *location,

912

             const char *fmt,

913

             ...) CAIRO_PRINTF_FORMAT (4, 5);

914

915

static void

916

parse_error (cairo_svg_glyph_render_t *svg_render,

917

             const char *string,

918

             const char *location,

919

             const char *fmt,

920

             ...)

921

922

    va_list ap;

923

    const int context = 40;

924

    const char *start;

925

    const char *end;

926

927

    if (svg_render->debug >= SVG_RENDER_ERROR) {

928

        printf("ERROR: ");

929

	va_start (ap, fmt);

930

	vprintf (fmt, ap);

931

	va_end (ap);

932

        putchar ('\n');

933

        start = location - context;

934

        if (start < string)

935

            start = string;

936

937

        end = location + strlen (location);

938

        if (end - location > context)

939

            end = location + context;

940

941

        for (const char *p = start; p < end; p++) {

942

            if (_cairo_isspace (*p))

943

                putchar (' ');

944

            else

945

                putchar (*p);

946

947

        putchar ('\n');

948

949

        for (int i = 0; i < location - start; i++)

950

            putchar(' ');

951

        putchar ('^');

952

        putchar ('\n');

953

	printf (" at position %td\n", location - string);

954

955

956

957

static cairo_bool_t

958

3927

append_attribute (cairo_svg_element_t *element, svg_attribute_t *attribute)

959

960

    const char *p;

961

    const char *end;

962

    svg_attribute_t attr;

963

964

3927

    memset (&attr, 0, sizeof (attr));

965

3927

    if (string_equal (attribute->name, "style")) {

966

        /* split style into individual attributes */

967

        p = attribute->value;

968

        while (*p) {

969

            end = strchr (p, ':');

970

            if (!end || end == p)

971

                break;

972

            attr.name = _cairo_strndup (p, end - p);

973

            p = end + 1;

974

            p = skip_space(p);

975

            end = strchr (p, ';');

976

            if (!end)

977

                end = strchr (p, 0);

978

            if (end == p)

979

                goto split_style_fail;

980

981

            attr.value = _cairo_strndup (p, end - p);

982

            if (*end)

983

                p = end + 1;

984

985

            if (_cairo_array_append (&element->attributes, &attr))

986

                goto split_style_fail;

987

988

            memset (&attr, 0, sizeof (attr));

989

            p = skip_space (p);

990

991

992

993

3927

    if (_cairo_array_append (&element->attributes, attribute))

994

        return FALSE;

995

996

3927

    return TRUE;

997

998

  split_style_fail:

999

    free (attr.name);

1000

    free (attr.value);

1001

    return FALSE;

1002

1003

1004

static cairo_bool_t

1005

1377

add_child_element (cairo_svg_glyph_render_t *svg_render,

1006

                   cairo_svg_element_t *parent,

1007

                   cairo_svg_element_t *child)

1008

1009

    cairo_status_t status;

1010

    const char* id;

1011

1012

1377

    id = get_attribute (child, "id");

1013

1377

    if (id) {

1014

207

        child->id = strdup (id);

1015

207

        init_element_id_key (child);

1016

207

	status = _cairo_hash_table_insert (svg_render->ids, &child->base);

1017

207

	if (unlikely (status))

1018

            return FALSE;

1019

1020

1021

1377

    status = _cairo_array_append (&parent->children, &child);

1022

1377

    return status == CAIRO_STATUS_SUCCESS;

1023

1024

1025

static cairo_svg_element_t *

1026

1647

create_element (tag_type_t type, char *tag)

1027

1028

    cairo_svg_element_t *elem;

1029

    cairo_status_t status;

1030

1031

1647

    elem = _cairo_calloc (sizeof (cairo_svg_element_t));

1032

1647

    if (unlikely (elem == NULL)) {

1033

	status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

1034

        return NULL;

1035

1036

1037

1647

    elem->type = type;

1038

1647

    elem->tag = tag;

1039

1647

    elem->id = NULL;

1040

1647

    _cairo_array_init (&elem->attributes, sizeof(svg_attribute_t));

1041

1647

    _cairo_array_init (&elem->children, sizeof(cairo_svg_element_t *));

1042

1647

    _cairo_array_init (&elem->content, sizeof(char));

1043

1647

    elem->pattern = NULL;

1044

1647

    elem->next = NULL;

1045

1046

1647

    return elem;

1047

1048

1049

static const char *

1050

1242

parse_attributes (cairo_svg_glyph_render_t *svg_render,

1051

                  const char               *attributes,

1052

                  cairo_svg_element_t      *element)

1053

1054

    svg_attribute_t attr;

1055

    char quote_char;

1056

    const char *p;

1057

    const char *end;

1058

1059

1242

    p = attributes;

1060

1242

    memset (&attr, 0, sizeof (svg_attribute_t));

1061

1242

    p = skip_space (p);

1062

5169

    while (*p && *p != '/' && *p != '>' && *p != '?') {

1063

3927

        end = strpbrk(p, WHITE_SPACE_CHARS "=");

1064

3927

        if (!end) {

1065

            parse_error (svg_render, attributes, p, "Could not find '='");

1066

            goto fail;

1067

1068

1069

3927

        if (end == p) {

1070

            parse_error (svg_render, attributes, p, "Missing attribute name");

1071

            goto fail;

1072

1073

1074

3927

        attr.name = _cairo_strndup (p, end - p);

1075

3927

        p = end;

1076

1077

3927

        p = skip_space (p);

1078

3927

        if (*p != '=') {

1079

            parse_error (svg_render, attributes, p, "Expected '='");

1080

            goto fail;

1081

1082

1083

3927

        p++;

1084

3927

        p = skip_space (p);

1085

3927

        if (*p == '\"' || *p == '\'') {

1086

3927

            quote_char = *p;

1087

        } else {

1088

            parse_error (svg_render, attributes, p, "Could not find '\"' or '''");

1089

            goto fail;

1090

1091

1092

3927

        p++;

1093

3927

        end = strchr (p, quote_char);

1094

3927

        if (!end) {

1095

            parse_error (svg_render, attributes, p, "Could not find '%c'", quote_char);

1096

            goto fail;

1097

1098

1099

3927

        attr.value = _cairo_strndup (p, end - p);

1100

3927

        p = end + 1;

1101

1102

3927

        if (!append_attribute (element, &attr))

1103

            goto fail;

1104

1105

3927

        memset (&attr, 0, sizeof (svg_attribute_t));

1106

1107

3927

        p = skip_space (p);

1108

1109

1110

1242

    return p;

1111

1112

  fail:

1113

    free (attr.name);

1114

    free (attr.value);

1115

    return NULL;

1116

1117

1118

static cairo_bool_t

1119

270

parse_svg (cairo_svg_glyph_render_t *svg_render,

1120

           const char               *svg_document)

1121

1122

270

    const char *p = svg_document;

1123

    const char *end;

1124

    int nesting; /* when > 0 we parse content */

1125

    cairo_svg_element_t *open_elem; /* Stack of open elements */

1126

270

    cairo_svg_element_t *new_elem = NULL;

1127

    char *name;

1128

    cairo_status_t status;

1129

1130

    /* Create top level element to use as a container for all top

1131

     * level elements in the document and push it on the stack. */

1132

270

    open_elem = create_element (CONTAINER_ELEMENT, strdup(TOP_ELEMENT_TAG));

1133

1134

    /* We don't want to add content to the top level container. There

1135

     * should only be whitesapce between tags. */

1136

270

    nesting = 0;

1137

1138

2190

    while (*p) {

1139

1920

        if (nesting > 0) {

1140

            /* In an open element. Anything before the next '<' is content */

1141

1644

            end = strchr (p, '<');

1142

1644

            if (!end) {

1143

                parse_error (svg_render, svg_document, p, "Could not find '<'");

1144

                goto fail;

1145

1146

1644

            status = _cairo_array_append_multiple (&open_elem->content, p, end - p);

1147

1644

            p = end;

1148

1149

        } else {

1150

276

            p = skip_space (p);

1151

276

            if (*p == 0)

1152

                break; /* end of document */

1153

1154

1155

        /* We should now be at the start of a tag */

1156

1920

        if (*p != '<') {

1157

            parse_error (svg_render, svg_document, p, "Could not find '<'");

1158

            goto fail;

1159

1160

1161

1920

        p++;

1162

1920

        if (*p == '!') {

1163

132

            p++;

1164

132

            if (string_match (&p, "[CDATA[")) {

1165

                new_elem = create_element (CDATA, NULL);

1166

                end = strstr (p, "]]>");

1167

                if (!end) {

1168

                    parse_error (svg_render, svg_document, p, "Could not find ']]>'");

1169

                    goto fail;

1170

1171

1172

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);

1173

                p = end + 3;

1174

132

            } else if (string_match (&p, "--")) {

1175

129

                new_elem = create_element (COMMENT, NULL);

1176

129

                end = strstr (p, "-->");

1177

129

                if (!end) {

1178

                    parse_error (svg_render, svg_document, p, "Could not find '-->'");

1179

                    goto fail;

1180

1181

1182

129

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);

1183

129

                p = end + 3;

1184

3

            } else if (string_match (&p, "DOCTYPE")) {

1185

3

                new_elem = create_element (DOCTYPE, NULL);

1186

3

                end = strchr (p, '>');

1187

3

                if (!end) {

1188

                    parse_error (svg_render, svg_document, p, "Could not find '>'");

1189

                    goto fail;

1190

1191

1192

3

                status = _cairo_array_append_multiple (&new_elem->content, p, end - p);

1193

3

                p = end + 1;

1194

            } else {

1195

                parse_error (svg_render, svg_document, p, "Invalid");

1196

                goto fail;

1197

1198

1199

132

            if (!add_child_element (svg_render, open_elem, new_elem))

1200

                goto fail;

1201

1202

132

            new_elem = NULL;

1203

132

            continue;

1204

1205

1206

1788

        if (*p == '?') {

1207

3

            p++;

1208

3

            new_elem = create_element (PROCESSING_INSTRUCTION, NULL);

1209

3

            end = strstr (p, "?>");

1210

3

            if (!end) {

1211

                parse_error (svg_render, svg_document, p, "Could not find '?>'");

1212

                goto fail;

1213

1214

1215

3

            status = _cairo_array_append_multiple (&new_elem->content, p, end - p);

1216

3

            p = end + 2;

1217

1218

3

            if (!add_child_element (svg_render, open_elem, new_elem))

1219

                goto fail;

1220

1221

3

            new_elem = NULL;

1222

3

            continue;

1223

1224

1225

1785

        if (*p == '/') {

1226

            /* Closing tag */

1227

543

            p++;

1228

1229

            /* find end of tag name */

1230

543

            end = strpbrk(p, WHITE_SPACE_CHARS ">");

1231

543

            if (!end) {

1232

                parse_error (svg_render, svg_document, p, "Could not find '>'");

1233

                goto fail;

1234

1235

1236

543

            name = _cairo_strndup (p, end - p);

1237

543

            p = end;

1238

543

            p = skip_space (p);

1239

543

            if (*p != '>') {

1240

                parse_error (svg_render, svg_document, p, "Could not find '>'");

1241

                free (name);

1242

                goto fail;

1243

1244

1245

543

            p++;

1246

543

            if (nesting == 0) {

1247

                parse_error (svg_render, svg_document, p, "parse_elements: parsed </%s> but no matching start tag", name);

1248

                free (name);

1249

                goto fail;

1250

1251

543

            if (!string_equal (name, open_elem->tag)) {

1252

                parse_error (svg_render, svg_document, p,

1253

                             "parse_elements: found </%s> but current open tag is <%s>",

1254

                             name, open_elem->tag);

1255

                free (name);

1256

                goto fail;

1257

1258

1259

            /* pop top element on open elements stack into new_elem */

1260

543

            new_elem = open_elem;

1261

543

            open_elem = open_elem->next;

1262

543

            new_elem->next = NULL;

1263

543

            nesting--;

1264

1265

543

            free (name);

1266

543

            if (!add_child_element (svg_render, open_elem, new_elem))

1267

                goto fail;

1268

1269

543

            new_elem = NULL;

1270

543

            continue;

1271

1272

1273

        /* We should now be in a start or empty element tag */

1274

1275

        /* find end of tag name */

1276

1242

        end = strpbrk(p, WHITE_SPACE_CHARS "/>");

1277

1242

        if (!end) {

1278

            parse_error (svg_render, svg_document, p, "Could not find '>'");

1279

            goto fail;

1280

1281

1282

1242

        name = _cairo_strndup (p, end - p);

1283

1242

        p = end;

1284

1285

1242

        new_elem = create_element (CONTAINER_ELEMENT, name);

1286

1242

        p = parse_attributes (svg_render, p, new_elem);

1287

1242

        if (!p)

1288

            goto fail;

1289

1290

1242

        p = skip_space (p);

1291

1242

        if (*p == '/') {

1292

699

            new_elem->type = EMPTY_ELEMENT;

1293

699

            p++;

1294

1295

1296

1242

        if (!p || *p != '>') {

1297

            print_error (svg_render, "Could not find '>'");

1298

            goto fail;

1299

1300

1301

1242

        p++;

1302

1242

        if (new_elem->type == EMPTY_ELEMENT) {

1303

699

            if (!add_child_element (svg_render, open_elem, new_elem))

1304

                goto fail;

1305

1306

699

            new_elem = NULL;

1307

        } else {

1308

            /* push new elem onto open elements stack */

1309

543

            new_elem->next = open_elem;

1310

543

            open_elem = new_elem;

1311

543

            new_elem = NULL;

1312

543

            nesting++;

1313

1314

1315

1316

270

    if (nesting != 0) {

1317

        parse_error (svg_render, svg_document, p, "Missing closing tag for <%s>", open_elem->tag);

1318

        goto fail;

1319

1320

1321

270

    svg_render->tree = open_elem;

1322

270

    return TRUE;

1323

1324

  fail:

1325

    if (new_elem)

1326

        free_elements (svg_render, new_elem);

1327

1328

    while (open_elem) {

1329

        cairo_svg_element_t *elem = open_elem;

1330

        open_elem = open_elem->next;

1331

        free_elements (svg_render, elem);

1332

1333

1334

    return FALSE;

1335

1336

1337

static cairo_bool_t

1338

174

parse_transform (const char *p, cairo_matrix_t *matrix)

1339

1340

    cairo_matrix_t m;

1341

    double x, y, a;

1342

    cairo_bool_t have_optional;

1343

1344

174

    cairo_matrix_init_identity (matrix);

1345

324

    while (p) {

1346

282

        while (p && (*p == ',' || _cairo_isspace (*p)))

1347

9

            p++;

1348

1349

273

        if (!p || *p == 0)

1350

            break;

1351

1352

150

        if (string_match (&p, "matrix")) {

1353

3

            p = skip_char (p, '(');

1354

3

            if (!p)

1355

                break;

1356

1357

3

            p = get_floats (p, 6, 0, NULL, &m.xx, &m.yx, &m.xy, &m.yy, &m.x0, &m.y0);

1358

3

            if (!p)

1359

                break;

1360

1361

3

            p = skip_char (p, ')');

1362

3

            if (!p)

1363

                break;

1364

1365

3

            cairo_matrix_multiply (matrix, &m, matrix);

1366

1367

147

        } else if (string_match (&p, "translate")) {

1368

96

            p = skip_char (p, '(');

1369

96

            if (!p)

1370

                break;

1371

1372

96

            p = get_floats (p, 1, 1, &have_optional, &x, &y);

1373

96

            if (!p)

1374

                break;

1375

1376

96

            p = skip_char (p, ')');

1377

96

            if (!p)

1378

                break;

1379

1380

96

            if (!have_optional)

1381

                y = 0;

1382

1383

96

            cairo_matrix_translate (matrix, x, y);

1384

1385

51

        } else if (string_match (&p, "scale")) {

1386

30

            p = skip_char (p, '(');

1387

30

            if (!p)

1388

                break;

1389

1390

30

            p = get_floats (p, 1, 1, &have_optional, &x, &y);

1391

30

            if (!p)

1392

                break;

1393

1394

30

            p = skip_char (p, ')');

1395

30

            if (!p)

1396

                break;

1397

1398

30

            if (!have_optional)

1399

6

                y = x;

1400

1401

30

            cairo_matrix_scale (matrix, x, y);

1402

1403

21

        } else if (string_match (&p, "rotate")) {

1404

12

            p = skip_char (p, '(');

1405

12

            if (!p)

1406

                break;

1407

1408

12

            p = get_floats (p, 1, 2, &have_optional, &a, &x, &y);

1409

12

            if (!p)

1410

                break;

1411

1412

12

            p = skip_char (p, ')');

1413

12

            if (!p)

1414

                break;

1415

1416

12

            if (!have_optional) {

1417

9

                x = 0;

1418

9

                y = 0;

1419

1420

1421

12

            a *= M_PI/180.0;

1422

12

            cairo_matrix_translate (matrix, x, y);

1423

12

            cairo_matrix_rotate (matrix, a);

1424

12

            cairo_matrix_translate (matrix, -x, -y);

1425

1426

9

        } else if (string_match (&p, "skewX")) {

1427

6

            p = skip_char (p, '(');

1428

6

            if (!p)

1429

                break;

1430

1431

6

            p = get_floats (p, 1, 0, NULL, &a);

1432

6

            if (!p)

1433

                break;

1434

1435

6

            p = skip_char (p, ')');

1436

6

            if (!p)

1437

                break;

1438

1439

6

            a *= M_PI/180.0;

1440

6

            cairo_matrix_init_identity (&m);

1441

6

            m.xy = tan (a);

1442

6

            cairo_matrix_multiply (matrix, &m, matrix);

1443

1444

3

        } else if (string_match (&p, "skewY")) {

1445

3

            p = skip_char (p, '(');

1446

3

            if (!p)

1447

                break;

1448

1449

3

            p = get_floats (p, 1, 0, NULL, &a);

1450

3

            if (!p)

1451

                break;

1452

1453

3

            p = skip_char (p, ')');

1454

3

            if (!p)

1455

                break;

1456

1457

3

            a *= M_PI/180.0;

1458

3

            cairo_matrix_init_identity (&m);

1459

3

            m.yx = tan (a);

1460

3

            cairo_matrix_multiply (matrix, &m, matrix);

1461

1462

        } else {

1463

            break;

1464

1465

1466

174

    return p != NULL;

1467

1468

1469

static void

1470

render_element_tree (cairo_svg_glyph_render_t *svg_render,

1471

                     cairo_svg_element_t      *element,

1472

                     cairo_svg_element_t      *display_element,

1473

                     cairo_bool_t              children_only);

1474

1475

static cairo_pattern_t *

1476

57

create_pattern (cairo_svg_glyph_render_t *svg_render,

1477

                cairo_svg_element_t      *paint_server)

1478

1479

57

    cairo_pattern_t *pattern = NULL;

1480

1481

57

    if (paint_server) {

1482

57

        svg_render->build_pattern.paint_server = paint_server;

1483

57

        render_element_tree (svg_render, paint_server, NULL, FALSE);

1484

57

        pattern = svg_render->build_pattern.pattern;

1485

57

        svg_render->build_pattern.pattern = NULL;

1486

57

        svg_render->build_pattern.paint_server = NULL;

1487

57

        svg_render->build_pattern.type = BUILD_PATTERN_NONE;

1488

1489

1490

57

    if (!pattern)

1491

        pattern = cairo_pattern_create_rgb (0, 0, 0);

1492

1493

57

    return pattern;

1494

1495

1496

static cairo_bool_t

1497

270

render_element_svg (cairo_svg_glyph_render_t *svg_render,

1498

                    cairo_svg_element_t      *element,

1499

                    cairo_bool_t              end_tag)

1500

1501

    double width, height;

1502

    double vb_x, vb_y, vb_height, vb_width;

1503

    const char *p;

1504

    const char *end;

1505

1506

270

    if (end_tag)

1507

        return FALSE;

1508

1509

    /* Default viewport width, height is EM square */

1510

270

    if (!get_float_or_percent_attribute (element, "width", svg_render->units_per_em, &width))

1511

246

        width = svg_render->units_per_em;

1512

1513

270

    if (!get_float_or_percent_attribute (element, "height", svg_render->units_per_em, &height))

1514

246

        height = svg_render->units_per_em;

1515

1516

    /* Transform viewport to unit square, centering it if width != height. */

1517

270

    if (width > height) {

1518

        cairo_scale (svg_render->cr, 1.0/width, 1.0/width);

1519

        cairo_translate (svg_render->cr, 0, (width - height)/2.0);

1520

    } else {

1521

270

        cairo_scale (svg_render->cr, 1.0/height, 1.0/height);

1522

270

        cairo_translate (svg_render->cr, (height - width)/2.0, 0);

1523

1524

1525

270

    svg_render->width = width;

1526

270

    svg_render->height = height;

1527

1528

270

    p = get_attribute (element, "viewBox");

1529

270

    if (p) {

1530

        /* Transform viewport to viewbox */

1531

6

        end = get_path_params (p, 4, &vb_x, &vb_y, &vb_width, &vb_height);

1532

6

        if (!end) {

1533

            print_warning (svg_render, "viewBox expected 4 numbers: %s", p);

1534

            return FALSE;

1535

1536

6

        cairo_translate (svg_render->cr, -vb_x * width/vb_width, -vb_y * width/vb_width);

1537

6

        cairo_scale (svg_render->cr, width/vb_width, height/vb_height);

1538

6

        svg_render->width = vb_width;

1539

6

        svg_render->height = vb_height;

1540

1541

1542

270

    svg_render->view_port_set = TRUE;

1543

270

    return TRUE;

1544

1545

1546

static cairo_bool_t

1547

96

render_element_clip_path (cairo_svg_glyph_render_t *svg_render,

1548

                          cairo_svg_element_t      *element,

1549

                          cairo_bool_t              end_tag)

1550

1551

96

    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

1552

    const char *p;

1553

1554

96

    if (end_tag || gs->mode != GS_CLIP || svg_render->build_pattern.type != BUILD_PATTERN_NONE) {

1555

72

        return FALSE;

1556

1557

1558

24

    p = get_attribute (element, "clipPathUnits");

1559

24

    if (string_equal (p, "objectBoundingBox")) {

1560

12

        cairo_translate (svg_render->cr,

1561

12

                                svg_render->graphics_state->bbox.x,

1562

12

                                svg_render->graphics_state->bbox.y);

1563

12

        cairo_scale (svg_render->cr,

1564

12

                     svg_render->graphics_state->bbox.width,

1565

12

                     svg_render->graphics_state->bbox.height);

1566

1567

1568

24

    return TRUE;

1569

1570

1571

static void

1572

57

apply_gradient_attributes (cairo_svg_glyph_render_t *svg_render,

1573

                           cairo_svg_element_t      *element)

1574

1575

57

    cairo_pattern_t *pattern = svg_render->build_pattern.pattern;

1576

57

    cairo_bool_t object_bbox = TRUE;

1577

    cairo_matrix_t transform;

1578

    cairo_matrix_t mat;

1579

    const char *p;

1580

1581

57

    if (!pattern)

1582

        return;

1583

1584

57

    p = get_attribute (element, "gradientUnits");

1585

57

    if (string_equal (p, "userSpaceOnUse"))

1586

9

        object_bbox = FALSE;

1587

1588

57

    cairo_matrix_init_identity (&mat);

1589

57

    if (object_bbox) {

1590

48

        cairo_matrix_translate (&mat,

1591

48

                                svg_render->graphics_state->bbox.x,

1592

48

                                svg_render->graphics_state->bbox.y);

1593

48

        cairo_matrix_scale (&mat,

1594

48

                            svg_render->graphics_state->bbox.width,

1595

48

                            svg_render->graphics_state->bbox.height);

1596

1597

1598

57

    p = get_attribute (element, "gradientTransform");

1599

57

     if (parse_transform (p, &transform))

1600

6

         cairo_matrix_multiply (&mat, &transform, &mat);

1601

1602

57

    if (cairo_matrix_invert (&mat) == CAIRO_STATUS_SUCCESS)

1603

57

        cairo_pattern_set_matrix (pattern, &mat);

1604

1605

57

    p = get_attribute (element, "spreadMethod");

1606

57

    if (string_equal (p, "reflect"))

1607

6

        cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REFLECT);

1608

51

    else if (string_equal (p, "repeat"))

1609

6

        cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);

1610

1611

1612

static cairo_bool_t

1613

54

render_element_linear_gradient (cairo_svg_glyph_render_t *svg_render,

1614

                                cairo_svg_element_t      *element,

1615

                                cairo_bool_t              end_tag)

1616

1617

    double x1, y1, x2, y2;

1618

1619

54

    if (svg_render->build_pattern.paint_server != element ||

1620

27

        end_tag ||

1621

27

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

1622

27

        return FALSE;

1623

1624

    /* FIXME default value for userSpaceOnUse? */

1625

27

    double width = 1.0;

1626

27

    double height = 1.0;

1627

1628

27

    if (!get_float_or_percent_attribute (element, "x1", width, &x1))

1629

3

        x1 = 0.0;

1630

1631

27

    if (!get_float_or_percent_attribute (element, "y1", height, &y1))

1632

24

        y1 = 0.0;

1633

1634

27

    if (!get_float_or_percent_attribute (element, "x2", width, &x2))

1635

18

        x2 = width;

1636

1637

27

    if (!get_float_or_percent_attribute (element, "y2", height, &y2))

1638

24

        y2 = 0.0;

1639

1640

27

    if (svg_render->build_pattern.pattern)

1641

        abort();

1642

1643

27

    svg_render->build_pattern.pattern = cairo_pattern_create_linear (x1, y1, x2, y2);

1644

27

    svg_render->build_pattern.type = BUILD_PATTERN_LINEAR;

1645

27

    apply_gradient_attributes (svg_render, element);

1646

27

    return TRUE;

1647

1648

1649

static cairo_bool_t

1650

60

render_element_radial_gradient (cairo_svg_glyph_render_t *svg_render,

1651

                                cairo_svg_element_t      *element,

1652

                                cairo_bool_t              end_tag)

1653

1654

    double cx, cy, r, fx, fy;

1655

1656

60

    if (svg_render->build_pattern.paint_server != element ||

1657

30

        end_tag ||

1658

30

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

1659

30

        return FALSE;

1660

1661

    /* FIXME default value for userSpaceOnUse? */

1662

30

    double width = 1.0;

1663

30

    double height = 1.0;

1664

1665

30

    if (!get_float_or_percent_attribute (element, "cx", width, &cx))

1666

        cx = 0.5 * width;

1667

1668

30

    if (!get_float_or_percent_attribute (element, "cy", height, &cy))

1669

        cy = 0.5 * height;

1670

1671

30

    if (!get_float_or_percent_attribute (element, "r", width, &r))

1672

        r = 0.5 * width;

1673

1674

30

    if (!get_float_or_percent_attribute (element, "fx", width, &fx))

1675

        fx = cx;

1676

1677

30

    if (!get_float_or_percent_attribute (element, "fy", height, &fy))

1678

        fy = cy;

1679

1680

30

    svg_render->build_pattern.pattern = cairo_pattern_create_radial (fx, fy, 0, cx, cy, r);

1681

30

    svg_render->build_pattern.type = BUILD_PATTERN_RADIAL;

1682

30

    apply_gradient_attributes (svg_render, element);

1683

30

    return TRUE;

1684

1685

1686

static cairo_bool_t

1687

117

render_element_stop (cairo_svg_glyph_render_t *svg_render,

1688

                     cairo_svg_element_t      *element,

1689

                     cairo_bool_t              end_tag)

1690

1691

    double offset, opacity;

1692

117

    cairo_pattern_t *pattern = svg_render->build_pattern.pattern;

1693

1694

117

    if (!pattern)

1695

        return FALSE;

1696

1697

180

    if (cairo_pattern_get_type (pattern) != CAIRO_PATTERN_TYPE_LINEAR &&

1698

63

        cairo_pattern_get_type (pattern) != CAIRO_PATTERN_TYPE_RADIAL)

1699

        return FALSE;

1700

1701

117

    if (!get_float_or_percent_attribute (element, "offset", 1.0, &offset))

1702

        return FALSE;

1703

1704

117

    if (!get_float_attribute (element, "stop-opacity", &opacity))

1705

9

        opacity = 1.0;

1706

1707

    cairo_svg_color_t color;

1708

117

    get_color (svg_render, "black", &color);

1709

117

    get_color (svg_render, get_attribute(element, "stop-color"), &color);

1710

117

    if (color.type == RGB) {

1711

93

        cairo_pattern_add_color_stop_rgba (pattern,

1712

                                           offset,

1713

                                           color.red,

1714

                                           color.green,

1715

                                           color.blue,

1716

                                           opacity);

1717

    } else { /* color.type == FOREGROUND */

1718

        double red, green, blue, alpha;

1719

24

        if (cairo_pattern_get_rgba (svg_render->foreground_source, &red, &green, &blue, &alpha) == CAIRO_STATUS_SUCCESS) {

1720

24

	    svg_render->foreground_source_used = TRUE;

1721

	} else {

1722

            red = green = blue = 0;

1723

            alpha = 1;

1724

1725

24

        cairo_pattern_add_color_stop_rgba (pattern, offset, red, green, blue, alpha);

1726

1727

117

    return TRUE;

1728

1729

1730

static cairo_bool_t

1731

138

render_element_g (cairo_svg_glyph_render_t *svg_render,

1732

                  cairo_svg_element_t      *element,

1733

                  cairo_bool_t              end_tag)

1734

1735

138

    if (svg_render->graphics_state->mode == GS_NO_RENDER ||

1736

138

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

1737

        return FALSE;

1738

1739

138

    if (!end_tag) {

1740

69

        cairo_push_group (svg_render->cr);

1741

    } else {

1742

69

        cairo_pop_group_to_source (svg_render->cr);

1743

69

        cairo_paint_with_alpha (svg_render->cr, svg_render->graphics_state->opacity);

1744

1745

138

    return TRUE;

1746

1747

1748

typedef struct {

1749

    const char *data; /* current position in base64 data */

1750

    char buf[3]; /* decode buffer */

1751

    int buf_pos; /* current position in buf_pos. */

1752

} base64_decode_t;

1753

1754

static cairo_status_t

1755

150

_read_png_from_base64 (void *closure, unsigned char *data, unsigned int length)

1756

1757

150

    base64_decode_t *decode = closure;

1758

    int n, c;

1759

    unsigned val;

1760

1761

39690

    while (length) {

1762

39540

        if (decode->buf_pos >= 0) {

1763

39498

            *data++ = decode->buf[decode->buf_pos++];

1764

39498

            length--;

1765

39498

            if (decode->buf_pos == 3)

1766

13164

                decode->buf_pos = -1;

1767

1768

39540

        if (length > 0 && decode->buf_pos < 0) {

1769

13170

            n = 0;

1770

13170

            val = 0;

1771

66546

            while (*decode->data && n < 4) {

1772

53376

                c = *decode->data++;

1773

53376

                if (c >='A' && c <='Z') {

1774

21744

                    val = (val << 6) | (c -'A');

1775

21744

                    n++;

1776

31632

                } else if (c >='a' && c <='z') {

1777

21222

                    val = (val << 6) | (c -'a' + 26);

1778

21222

                    n++;

1779

10410

                } else if (c >='0' && c <='9') {

1780

8088

                    val = (val << 6) | (c -'0' + 52);

1781

8088

                    n++;

1782

2322

                } else if (c =='+') {

1783

786

                    val = (val << 6) | 62;

1784

786

                    n++;

1785

1536

                } else if (c =='/') {

1786

828

                    val = (val << 6) | 63;

1787

828

                    n++;

1788

708

                } else if (c == '=') {

1789

12

                    val = (val << 6);

1790

12

                    n++;

1791

1792

1793

13170

            if (n < 4)

1794

                return CAIRO_STATUS_READ_ERROR;

1795

1796

13170

            decode->buf[0] = val >> 16;

1797

13170

            decode->buf[1] = val >> 8;

1798

13170

            decode->buf[2] = val >> 0;

1799

13170

            decode->buf_pos = 0;

1800

1801

1802

1803

150

    return CAIRO_STATUS_SUCCESS;

1804

1805

1806

static cairo_bool_t

1807

6

render_element_image (cairo_svg_glyph_render_t *svg_render,

1808

                      cairo_svg_element_t      *element,

1809

                      cairo_bool_t              end_tag)

1810

1811

    double x, y, width, height;

1812

    int w, h;

1813

    const char *data;

1814

    cairo_surface_t *surface;

1815

    base64_decode_t decode;

1816

1817

6

    if (svg_render->graphics_state->mode == GS_NO_RENDER ||

1818

6

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

1819

        return FALSE;

1820

1821

6

    if (!get_float_attribute (element, "x", &x))

1822

        x = 0;

1823

1824

6

    if (!get_float_attribute (element, "y", &y))

1825

        y = 0;

1826

1827

6

    if (!get_float_attribute (element, "width", &width))

1828

        return FALSE;

1829

1830

6

    if (!get_float_attribute (element, "height", &height))

1831

        return FALSE;

1832

1833

6

    data = get_href_attribute (element);

1834

6

    if (!data)

1835

        return FALSE;

1836

1837

6

    if (!string_match (&data, "data:image/png;base64,"))

1838

        return FALSE;

1839

1840

6

    decode.data = data;

1841

6

    decode.buf_pos = -1;

1842

6

    surface = cairo_image_surface_create_from_png_stream (_read_png_from_base64, &decode);

1843

6

    if (cairo_surface_status (surface)) {

1844

        print_warning (svg_render, "Unable to decode PNG");

1845

        cairo_surface_destroy (surface);

1846

        return FALSE;

1847

1848

1849

6

    w = cairo_image_surface_get_width (surface);

1850

6

    h = cairo_image_surface_get_height (surface);

1851

1852

6

    if (w > 0 && h > 0) {

1853

6

        cairo_translate (svg_render->cr, x, y);

1854

6

        cairo_scale (svg_render->cr, width/w, height/h);

1855

6

        cairo_set_source_surface (svg_render->cr, surface, 0, 0);

1856

6

        cairo_paint (svg_render->cr);

1857

1858

1859

6

    cairo_surface_destroy (surface);

1860

1861

6

    return FALSE;

1862

1863

1864

static cairo_bool_t

1865

72

render_element_use (cairo_svg_glyph_render_t *svg_render,

1866

                    cairo_svg_element_t      *element,

1867

                    cairo_bool_t              end_tag)

1868

1869

72

    double x = 0;

1870

72

    double y = 0;

1871

    const char *id;

1872

1873

72

    if (end_tag || svg_render->graphics_state->mode == GS_NO_RENDER ||

1874

72

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

1875

        return FALSE;

1876

1877

72

    get_float_attribute (element, "x", &x);

1878

72

    get_float_attribute (element, "y", &y);

1879

1880

72

    id = get_href_attribute (element);

1881

72

    if (!id)

1882

        return FALSE;

1883

1884

72

    cairo_svg_element_t *use_element = lookup_element (svg_render, id);

1885

72

    cairo_translate (svg_render->cr, x, y);

1886

72

    render_element_tree (svg_render, use_element, NULL, FALSE);

1887

72

    return TRUE;

1888

1889

1890

static cairo_bool_t

1891

504

draw_path (cairo_svg_glyph_render_t *svg_render)

1892

1893

504

    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

1894

    cairo_pattern_t *pattern;

1895

504

    cairo_bool_t opacity_group = FALSE;

1896

1897

504

    if (gs->mode == GS_COMPUTE_BBOX) {

1898

60

        cairo_set_source_rgb (svg_render->cr, 0, 0, 0);

1899

60

        cairo_set_fill_rule (svg_render->cr, gs->fill_rule);

1900

60

        cairo_fill (svg_render->cr);

1901

60

        return FALSE;

1902

444

    } else if (gs->mode == GS_CLIP) {

1903

30

        return FALSE;

1904

1905

1906

414

    if (gs->opacity < 1.0) {

1907

        cairo_push_group (svg_render->cr);

1908

        opacity_group = TRUE;

1909

1910

1911

414

    cairo_path_t *path = cairo_copy_path (svg_render->cr);

1912

414

    cairo_new_path (svg_render->cr);

1913

1914

414

    if (gs->fill.type != PAINT_NONE) {

1915

300

        cairo_bool_t group = FALSE;

1916

300

        if (gs->fill.type == PAINT_COLOR) {

1917

243

            if (gs->fill.color.type == RGB) {

1918

234

                cairo_set_source_rgba (svg_render->cr,

1919

                                       gs->fill.color.red,

1920

                                       gs->fill.color.green,

1921

                                       gs->fill.color.blue,

1922

                                       gs->fill_opacity);

1923

9

            } else if (gs->fill.color.type == FOREGROUND) {

1924

9

		cairo_set_source (svg_render->cr, svg_render->foreground_marker);

1925

9

		if (gs->fill_opacity < 1.0)

1926

3

		    group = TRUE;

1927

1928

57

        } else if (gs->fill.type == PAINT_SERVER) {

1929

57

            pattern = create_pattern (svg_render, gs->fill.paint_server);

1930

57

            cairo_set_source (svg_render->cr, pattern);

1931

57

            cairo_pattern_destroy (pattern);

1932

57

            if (gs->fill_opacity < 1.0)

1933

                group = TRUE;

1934

1935

1936

300

        if (group)

1937

3

            cairo_push_group (svg_render->cr);

1938

1939

300

        cairo_append_path (svg_render->cr, path);

1940

300

        cairo_set_fill_rule (svg_render->cr, gs->fill_rule);

1941

300

        cairo_fill (svg_render->cr);

1942

300

        if (group) {

1943

3

            cairo_pop_group_to_source (svg_render->cr);

1944

3

            cairo_paint_with_alpha (svg_render->cr, gs->fill_opacity);

1945

1946

1947

1948

414

    if (gs->stroke.type != PAINT_NONE) {

1949

135

        cairo_bool_t group = FALSE;

1950

135

        if (gs->stroke.type == PAINT_COLOR) {

1951

135

            if (gs->stroke.color.type == RGB) {

1952

132

                cairo_set_source_rgba (svg_render->cr,

1953

                                       gs->stroke.color.red,

1954

                                       gs->stroke.color.green,

1955

                                       gs->stroke.color.blue,

1956

                                       gs->stroke_opacity);

1957

3

            } else if (gs->fill.color.type == FOREGROUND) {

1958

		cairo_set_source (svg_render->cr, svg_render->foreground_marker);

1959

		if (gs->fill_opacity < 1.0)

1960

		    group = TRUE;

1961

1962

        } else if (gs->stroke.type == PAINT_SERVER) {

1963

            pattern = create_pattern (svg_render, gs->stroke.paint_server);

1964

            cairo_set_source (svg_render->cr, pattern);

1965

            cairo_pattern_destroy (pattern);

1966

            if (gs->stroke_opacity < 1.0)

1967

                group = TRUE;

1968

1969

1970

135

        if (group)

1971

            cairo_push_group (svg_render->cr);

1972

1973

135

        cairo_append_path (svg_render->cr, path);

1974

135

        cairo_stroke (svg_render->cr);

1975

1976

135

        if (group) {

1977

            cairo_pop_group_to_source (svg_render->cr);

1978

            cairo_paint_with_alpha (svg_render->cr, gs->stroke_opacity);

1979

1980

1981

1982

414

    cairo_path_destroy (path);

1983

1984

414

    if (opacity_group) {

1985

        cairo_pop_group_to_source (svg_render->cr);

1986

        cairo_paint_with_alpha (svg_render->cr, gs->opacity);

1987

1988

414

    return TRUE;

1989

1990

1991

static void

1992

15

elliptical_arc (cairo_svg_glyph_render_t *svg_render,

1993

                double                    cx,

1994

                double                    cy,

1995

                double                    rx,

1996

                double                    ry,

1997

                double                    angle1,

1998

                double                    angle2)

1999

2000

15

    cairo_save (svg_render->cr);

2001

15

    cairo_translate (svg_render->cr, cx, cy);

2002

15

    cairo_scale (svg_render->cr, rx, ry);

2003

15

    cairo_arc (svg_render->cr, 0, 0, 1, angle1, angle2);

2004

15

    cairo_restore (svg_render->cr);

2005

15

2006

2007

static cairo_bool_t

2008

282

render_element_rect (cairo_svg_glyph_render_t *svg_render,

2009

                     cairo_svg_element_t      *element,

2010

                     cairo_bool_t              end_tag)

2011

2012

282

    double x = 0;

2013

282

    double y = 0;

2014

282

    double width = svg_render->width;

2015

282

    double height = svg_render->height;

2016

282

    double rx = 0;

2017

282

    double ry = 0;

2018

2019

282

    if (end_tag ||

2020

282

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2021

282

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2022

        return FALSE;

2023

2024

282

    get_float_or_percent_attribute (element, "x", svg_render->width, &x);

2025

282

    get_float_or_percent_attribute (element, "y", svg_render->height, &y);

2026

282

    get_float_or_percent_attribute (element, "width", svg_render->width, &width);

2027

282

    get_float_or_percent_attribute (element, "height", svg_render->height, &height);

2028

282

    get_float_or_percent_attribute (element, "rx", svg_render->width, &rx);

2029

282

    get_float_or_percent_attribute (element, "ry", svg_render->height, &ry);

2030

2031

282

    if (rx == 0 && ry == 0) {

2032

279

        cairo_rectangle (svg_render->cr, x, y, width, height);

2033

    } else {

2034

3

        cairo_move_to (svg_render->cr, x + rx, y);

2035

3

        cairo_line_to (svg_render->cr, x + width - rx, y);

2036

3

        elliptical_arc (svg_render,    x + width - rx, y + ry, rx, ry, -M_PI/2, 0);

2037

3

        cairo_line_to (svg_render->cr, x + width, y + height - ry);

2038

3

        elliptical_arc (svg_render,    x + width - rx, y + height - ry, rx, ry, 0, M_PI/2);

2039

3

        cairo_line_to (svg_render->cr, x + rx, y + height);

2040

3

        elliptical_arc (svg_render,    x + rx, y + height - ry, rx, ry, M_PI/2, M_PI);

2041

3

        cairo_line_to (svg_render->cr, x, y + ry);

2042

3

        elliptical_arc (svg_render,    x + rx, y + ry, rx, ry, M_PI, -M_PI/2);

2043

2044

2045

282

    draw_path (svg_render);

2046

282

    return TRUE;

2047

2048

2049

static cairo_bool_t

2050

51

render_element_circle (cairo_svg_glyph_render_t *svg_render,

2051

                       cairo_svg_element_t      *element,

2052

                       cairo_bool_t              end_tag)

2053

2054

51

    double cx = 0;

2055

51

    double cy = 0;

2056

51

    double r = 0;

2057

2058

51

    if (end_tag ||

2059

51

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2060

51

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2061

        return FALSE;

2062

2063

51

    get_float_or_percent_attribute (element, "cx", svg_render->width, &cx);

2064

51

    get_float_or_percent_attribute (element, "cy", svg_render->height, &cy);

2065

51

    get_float_or_percent_attribute (element, "r", svg_render->width, &r);

2066

2067

51

    cairo_arc (svg_render->cr, cx, cy, r, 0, 2*M_PI);

2068

2069

51

    draw_path (svg_render);

2070

51

    return TRUE;

2071

2072

2073

static cairo_bool_t

2074

3

render_element_ellipse (cairo_svg_glyph_render_t *svg_render,

2075

                        cairo_svg_element_t      *element,

2076

                        cairo_bool_t              end_tag)

2077

2078

3

    double cx = 0;

2079

3

    double cy = 0;

2080

3

    double rx = 0;

2081

3

    double ry = 0;

2082

2083

3

    if (end_tag ||

2084

3

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2085

3

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2086

        return FALSE;

2087

2088

3

    get_float_or_percent_attribute (element, "cx", svg_render->width, &cx);

2089

3

    get_float_or_percent_attribute (element, "cy", svg_render->height, &cy);

2090

3

    get_float_or_percent_attribute (element, "rx", svg_render->width, &rx);

2091

3

    get_float_or_percent_attribute (element, "ry", svg_render->height, &ry);

2092

2093

3

    elliptical_arc (svg_render, cx, cy, rx, ry, 0, 2*M_PI);

2094

3

    draw_path (svg_render);

2095

3

    return TRUE;

2096

2097

2098

static cairo_bool_t

2099

75

render_element_line (cairo_svg_glyph_render_t *svg_render,

2100

                     cairo_svg_element_t      *element,

2101

                     cairo_bool_t              end_tag)

2102

2103

75

    double x1 = 0;

2104

75

    double y1 = 0;

2105

75

    double x2 = 0;

2106

75

    double y2 = 0;

2107

2108

75

    if (end_tag ||

2109

75

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2110

75

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2111

        return FALSE;

2112

2113

75

    get_float_or_percent_attribute (element, "x1", svg_render->width, &x1);

2114

75

    get_float_or_percent_attribute (element, "y1", svg_render->height, &y1);

2115

75

    get_float_or_percent_attribute (element, "x2", svg_render->width, &x2);

2116

75

    get_float_or_percent_attribute (element, "y2", svg_render->height, &y2);

2117

2118

75

    cairo_move_to (svg_render->cr, x1, y1);

2119

75

    cairo_line_to (svg_render->cr, x2, y2);

2120

2121

75

    draw_path (svg_render);

2122

75

    return TRUE;

2123

2124

2125

static cairo_bool_t

2126

24

render_element_polyline (cairo_svg_glyph_render_t *svg_render,

2127

                         cairo_svg_element_t      *element,

2128

                         cairo_bool_t              end_tag)

2129

2130

    const char *p;

2131

    const char *end;

2132

    double x, y;

2133

24

    cairo_bool_t have_move = FALSE;

2134

2135

24

    if (end_tag ||

2136

24

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2137

24

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2138

        return FALSE;

2139

2140

24

    p = get_attribute (element, "points");

2141

    do {

2142

123

        end = get_path_params (p, 2, &x, &y);

2143

123

        if (!end) {

2144

            print_warning (svg_render, "points expected 2 numbers: %s", p);

2145

            break;

2146

2147

123

        p = end;

2148

123

        if (!have_move) {

2149

24

            cairo_move_to (svg_render->cr, x, y);

2150

24

            have_move = TRUE;

2151

        } else {

2152

99

            cairo_line_to (svg_render->cr, x, y);

2153

2154

123

        p = skip_space (p);

2155

123

    } while (p && *p);

2156

2157

24

    if (string_equal (element->tag, "polygon"))

2158

9

        cairo_close_path (svg_render->cr);

2159

2160

24

    draw_path (svg_render);

2161

24

    return TRUE;

2162

2163

2164

static double

2165

42

angle_between_vectors (double ux,

2166

                       double uy,

2167

                       double vx,

2168

                       double vy)

2169

2170

42

    double dot = ux*vx + uy*vy;

2171

42

    double umag = sqrt (ux*ux + uy*uy);

2172

42

    double vmag = sqrt (vx*vx + vy*vy);

2173

42

    double c = dot/(umag*vmag);

2174

42

    if (c > 1.0)

2175

        c = 1.0;

2176

2177

42

    if (c < -1.0)

2178

3

        c = -1.0;

2179

2180

42

    double a = acos (c);

2181

42

    if (ux * vy - uy * vx < 0.0)

2182

12

        a = -a;

2183

2184

42

    return a;

2185

2186

2187

static void

2188

21

arc_path (cairo_t *cr,

2189

          double x1, double y1,

2190

          double x2, double y2,

2191

          double rx, double ry,

2192

          double rotate,

2193

          cairo_bool_t large_flag,

2194

          cairo_bool_t sweep_flag)

2195

2196

    double x1_, y1_, cx_, cy_;

2197

    double xm, ym, cx, cy;

2198

    double a, b, d;

2199

    double ux, uy, vx, vy;

2200

    double theta, delta_theta;

2201

    double epsilon;

2202

    cairo_matrix_t ctm;

2203

2204

21

    cairo_get_matrix (cr, &ctm);

2205

21

    epsilon = _cairo_matrix_transformed_circle_major_axis (&ctm, cairo_get_tolerance (cr));

2206

2207

21

    rotate *= M_PI/180.0;

2208

2209

    /* Convert endpoint to center parameterization.

2210

     * See SVG 1.1 Appendix F.6. Step numbers are the steps in the appendix.

2211

*/

2212

2213

21

    rx = fabs (rx);

2214

21

    ry = fabs (ry);

2215

21

    if (rx < epsilon || ry < epsilon) {

2216

        cairo_line_to (cr, x2, y2);

2217

        return;

2218

2219

2220

21

    if (fabs(x1 - x2) < epsilon && fabs(y1 - y2) < epsilon) {

2221

        cairo_line_to (cr, x2, y2);

2222

        return;

2223

2224

2225

    /* Step 1 */

2226

21

    xm = (x1 - x2)/2;

2227

21

    ym = (y1 - y2)/2;

2228

21

    x1_ = xm * cos (rotate) + ym * sin (rotate);

2229

21

    y1_ = xm * -sin (rotate) + ym * cos (rotate);

2230

2231

21

    d = (x1_*x1_)/(rx*rx) + (y1_*y1_)/(ry*ry);

2232

21

    if (d > 1.0) {

2233

15

        d = sqrt (d);

2234

15

        rx *= d;

2235

15

        ry *= d;

2236

2237

2238

    /* Step 2 */

2239

21

    a = (rx*rx * y1_*y1_) + (ry*ry * x1_*x1_);

2240

21

    if (a == 0.0)

2241

        return;

2242

2243

21

    b = (rx*rx * ry*ry) / a - 1.0;

2244

21

    if (b < 0)

2245

3

        b = 0.0;

2246

2247

21

    d = sqrt(b);

2248

21

    if (large_flag == sweep_flag)

2249

6

        d = -d;

2250

2251

21

    cx_ = d * rx*y1_/ry;

2252

21

    cy_ = d * -ry*x1_/rx;

2253

2254

    /* Step 3 */

2255

21

    cx = cx_ * cos (rotate) - cy_ * sin (rotate) + (x1 + x2)/2;

2256

21

    cy = cx_ * sin (rotate) + cy_ * cos (rotate) + (y1 + y2)/2;

2257

2258

    /* Step 4 */

2259

21

    ux = (x1_ - cx_)/rx;

2260

21

    uy = (y1_ - cy_)/ry;

2261

21

    vx = (-x1_ - cx_)/rx;

2262

21

    vy = (-y1_ - cy_)/ry;

2263

21

    theta = angle_between_vectors (1.0, 0, ux, uy);

2264

21

    delta_theta = angle_between_vectors (ux, uy, vx, vy);

2265

2266

21

    if (!sweep_flag && delta_theta > 0)

2267

3

        delta_theta -= 2 * M_PI;

2268

18

    else if (sweep_flag && delta_theta < 0)

2269

        delta_theta += 2 * M_PI;

2270

2271

    /* Now we can call cairo_arc() */

2272

21

    cairo_save (cr);

2273

21

    cairo_translate (cr, cx, cy);

2274

21

    cairo_scale (cr, rx, ry);

2275

21

    cairo_rotate (cr, theta);

2276

21

    if (delta_theta >= 0.0)

2277

18

        cairo_arc (cr, 0, 0, 1, 0, delta_theta);

2278

    else

2279

3

        cairo_arc_negative (cr, 0, 0, 1, 0, delta_theta);

2280

21

    cairo_restore (cr);

2281

2282

2283

static void

2284

393

get_current_point (cairo_svg_glyph_render_t *svg_render, double *x, double *y)

2285

2286

393

    if (cairo_has_current_point (svg_render->cr)) {

2287

393

        cairo_get_current_point (svg_render->cr, x, y);

2288

    } else {

2289

        *x = 0;

2290

        *y = 0;

2291

2292

393

2293

2294

static void

2295

15

reflect_point (double origin_x, double origin_y, double *x, double *y)

2296

2297

15

    *x = 2*origin_x - *x;

2298

15

    *y = 2*origin_y - *y;

2299

15

2300

2301

static cairo_bool_t

2302

69

render_element_path (cairo_svg_glyph_render_t *svg_render,

2303

                     cairo_svg_element_t      *element,

2304

                     cairo_bool_t              end_tag)

2305

2306

    double cur_x, cur_y;

2307

    double last_cp_x, last_cp_y;

2308

    double x, y, x1, y1, x2, y2;

2309

    double qx1, qy1, qx2, qy2;

2310

    double rx, ry, rotate, large_flag, sweep_flag;

2311

    cairo_bool_t rel, have_move;

2312

    enum { CUBIC, QUADRATIC, OTHER } last_op;

2313

2314

69

    if (end_tag ||

2315

69

        svg_render->graphics_state->mode == GS_NO_RENDER ||

2316

69

        svg_render->build_pattern.type != BUILD_PATTERN_NONE)

2317

        return FALSE;

2318

2319

69

    last_op = OTHER;

2320

69

    const char *p = get_attribute (element, "d");

2321

    const char *end;

2322

    int op;

2323

2324

801

    while (p) {

2325

990

        while (p && _cairo_isspace (*p))

2326

189

            p++;

2327

2328

801

        if (!p || *p == 0)

2329

            break;

2330

2331

732

        op = *p;

2332

732

        switch (op) {

2333

81

            case 'M':

2334

            case 'm':

2335

81

                rel = op == 'm';

2336

81

                p++;

2337

81

                have_move = FALSE;

2338

                do {

2339

81

                    end = get_path_params (p, 2, &x, &y);

2340

81

                    if (!end) {

2341

                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);

2342

                        break;

2343

2344

81

                    p = end;

2345

81

                    if (rel) {

2346

                        get_current_point (svg_render, &cur_x, &cur_y);

2347

                        x += cur_x;

2348

                        y += cur_y;

2349

2350

81

                    if (!have_move) {

2351

81

                        cairo_move_to (svg_render->cr, x, y);

2352

81

                        have_move = TRUE;

2353

                    } else {

2354

                        cairo_line_to (svg_render->cr, x, y);

2355

2356

81

                    p = skip_space (p);

2357

81

                } while (p && *p && !_cairo_isalpha(*p));

2358

81

                last_op = OTHER;

2359

81

                break;

2360

48

            case 'Z':

2361

            case 'z':

2362

48

                p++;

2363

48

                cairo_close_path (svg_render->cr);

2364

48

                last_op = OTHER;

2365

48

                break;

2366

114

            case 'L':

2367

            case 'l':

2368

114

                rel = op == 'l';

2369

114

                p++;

2370

                do {

2371

114

                    end = get_path_params (p, 2, &x, &y);

2372

114

                    if (!end) {

2373

                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);

2374

                        break;

2375

2376

114

                    p = end;

2377

114

                    if (rel) {

2378

42

                        get_current_point (svg_render, &cur_x, &cur_y);

2379

42

                        x += cur_x;

2380

42

                        y += cur_y;

2381

2382

114

                    cairo_line_to (svg_render->cr, x, y);

2383

114

                    p = skip_space (p);

2384

114

                } while (p && *p && !_cairo_isalpha(*p));

2385

114

                last_op = OTHER;

2386

114

                break;

2387

6

            case 'H':

2388

            case 'h':

2389

6

                rel = op == 'h';

2390

6

                p++;

2391

                do {

2392

6

                    end = get_path_params (p, 1, &x1);

2393

6

                    if (!end) {

2394

                        print_warning (svg_render, "path %c expected a number: %s", op, p);

2395

                        break;

2396

2397

6

                    p = end;

2398

6

                    get_current_point (svg_render, &cur_x, &cur_y);

2399

6

                    if (rel) {

2400

3

                        x1 += cur_x;

2401

2402

6

                    cairo_line_to (svg_render->cr, x1, cur_y);

2403

6

                    p = skip_space (p);

2404

6

                } while (p && *p && !_cairo_isalpha(*p));

2405

6

                last_op = OTHER;

2406

6

                break;

2407

3

            case 'V':

2408

            case 'v':

2409

3

                rel = op == 'v';

2410

3

                p++;

2411

                do {

2412

3

                    end = get_path_params (p, 1, &y1);

2413

3

                    if (!end) {

2414

                        print_warning (svg_render, "path %c expected a number: %s", op, p);

2415

                        break;

2416

2417

3

                    p = end;

2418

3

                    get_current_point (svg_render, &cur_x, &cur_y);

2419

3

                    if (rel) {

2420

                        y1 += cur_y;

2421

2422

3

                    cairo_line_to (svg_render->cr, cur_x, y1);

2423

3

                    p = skip_space (p);

2424

3

                } while (p && *p && !_cairo_isalpha(*p));

2425

3

                last_op = OTHER;

2426

3

                break;

2427

429

            case 'C':

2428

            case 'c':

2429

429

                rel = op == 'c';

2430

429

                p++;

2431

                do {

2432

429

                    end = get_path_params (p, 6, &x1, &y1, &x2, &y2, &x, &y);

2433

429

                    if (!end) {

2434

                        print_warning (svg_render, "path %c expected 6 numbers: %s", op, p);

2435

                        break;

2436

2437

429

                    p = end;

2438

429

                    if (rel) {

2439

291

                        get_current_point (svg_render, &cur_x, &cur_y);

2440

291

                        x1 += cur_x;

2441

291

                        y1 += cur_y;

2442

291

                        x2 += cur_x;

2443

291

                        y2 += cur_y;

2444

291

                        x += cur_x;

2445

291

                        y += cur_y;

2446

2447

429

                    cairo_curve_to (svg_render->cr, x1, y1, x2, y2, x, y);

2448

429

                    p = skip_space (p);

2449

429

                } while (p && *p && !_cairo_isalpha(*p));

2450

429

                last_op = CUBIC;

2451

429

                last_cp_x = x2;

2452

429

                last_cp_y = y2;

2453

429

                break;

2454

12

            case 'S':

2455

            case 's':

2456

12

                rel = op == 's';

2457

12

                p++;

2458

                do {

2459

12

                    end = get_path_params (p, 4, &x2, &y2, &x, &y);

2460

12

                    if (!end) {

2461

                        print_warning (svg_render, "path %c expected 4 numbers: %s", op, p);

2462

                        break;

2463

2464

12

                    p = end;

2465

12

                    get_current_point (svg_render, &cur_x, &cur_y);

2466

12

                    if (rel) {

2467

3

                        x2 += cur_x;

2468

3

                        y2 += cur_y;

2469

3

                        x += cur_x;

2470

3

                        y += cur_y;

2471

2472

12

                    if (last_op == CUBIC) {

2473

12

                        x1 = last_cp_x;

2474

12

                        y1 = last_cp_y;

2475

12

                        reflect_point (cur_x, cur_y, &x1, &y1);

2476

                    } else {

2477

                        x1 = cur_x;

2478

                        y1 = cur_y;

2479

2480

12

                    cairo_curve_to (svg_render->cr, x1, y1, x2, y2, x, y);

2481

12

                    last_op = CUBIC;

2482

12

                    last_cp_x = x2;

2483

12

                    last_cp_y = y2;

2484

12

                    p = skip_space (p);

2485

12

                } while (p && *p && !_cairo_isalpha(*p));

2486

12

                break;

2487

15

            case 'Q':

2488

            case 'q':

2489

15

                rel = op == 'q';

2490

15

                p++;

2491

                do {

2492

15

                    end = get_path_params (p, 4, &x1, &y1, &x, &y);

2493

15

                    if (!end) {

2494

                        print_warning (svg_render, "path %c expected 4 numbers: %s", op, p);

2495

                        break;

2496

2497

15

                    p = end;

2498

15

                    get_current_point (svg_render, &cur_x, &cur_y);

2499

15

                    if (rel) {

2500

                        x1 += cur_x;

2501

                        y1 += cur_y;

2502

                        x += cur_x;

2503

                        y += cur_y;

2504

2505

15

                    qx1 = cur_x + (x1 - cur_x)*2/3;

2506

15

                    qy1 = cur_y + (y1 - cur_y)*2/3;

2507

15

                    qx2 = x + (x1 - x)*2/3;

2508

15

                    qy2 = y + (y1 - y)*2/3;

2509

15

                    cairo_curve_to (svg_render->cr, qx1, qy1, qx2, qy2, x, y);

2510

15

                    p = skip_space (p);

2511

15

                } while (p && *p && !_cairo_isalpha(*p));

2512

15

                last_op = QUADRATIC;

2513

15

                last_cp_x = x1;

2514

15

                last_cp_y = y1;

2515

15

                break;

2516

3

            case 'T':

2517

            case 't':

2518

3

                rel = op == 't';

2519

3

                p++;

2520

                do {

2521

3

                    end = get_path_params (p, 2, &x, &y);

2522

3

                    if (!end) {

2523

                        print_warning (svg_render, "path %c expected 2 numbers: %s", op, p);

2524

                        break;

2525

2526

3

                    p = end;

2527

3

                    get_current_point (svg_render, &cur_x, &cur_y);

2528

3

                    if (rel) {

2529

                        x += cur_x;

2530

                        y += cur_y;

2531

2532

3

                    if (last_op == QUADRATIC) {

2533

3

                        x1 = last_cp_x;

2534

3

                        y1 = last_cp_y;

2535

3

                        reflect_point (cur_x, cur_y, &x1, &y1);

2536

                    } else {

2537

                        x1 = cur_x;

2538

                        y1 = cur_y;

2539

2540

3

                    qx1 = cur_x + (x1 - cur_x)*2/3;

2541

3

                    qy1 = cur_y + (y1 - cur_y)*2/3;

2542

3

                    qx2 = x + (x1 - x)*2/3;

2543

3

                    qy2 = y + (y1 - y)*2/3;

2544

3

                    cairo_curve_to (svg_render->cr, qx1, qy1, qx2, qy2, x, y);

2545

3

                    last_op = QUADRATIC;

2546

3

                    last_cp_x = x1;

2547

3

                    last_cp_y = y1;

2548

3

                    p = skip_space (p);

2549

3

                } while (p && *p && *p && !_cairo_isalpha(*p));

2550

3

                break;

2551

21

            case 'A':

2552

            case 'a':

2553

21

                rel = op == 'a';

2554

21

                p++;

2555

                do {

2556

21

                    end = get_path_params (p, 7, &rx, &ry, &rotate, &large_flag, &sweep_flag, &x, &y);

2557

21

                    if (!end) {

2558

                        print_warning (svg_render, "path %c expected 7 numbers: %s", op, p);

2559

                        break;

2560

2561

21

                    p = end;

2562

21

                    get_current_point (svg_render, &cur_x, &cur_y);

2563

21

                    if (rel) {

2564

                        x += cur_x;

2565

                        y += cur_y;

2566

2567

21

                    arc_path (svg_render->cr,

2568

                              cur_x, cur_y,

2569

                              x, y,

2570

                              rx, ry,

2571

                              rotate,

2572

                              large_flag > 0.5,

2573

                              sweep_flag > 0.5);

2574

21

                    p = skip_space (p);

2575

21

                } while (p && *p && !_cairo_isalpha(*p));

2576

21

                last_op = OTHER;

2577

21

                break;

2578

            default:

2579

                p = NULL;

2580

                break;

2581

2582

2583

2584

69

    draw_path (svg_render);

2585

69

    return TRUE;

2586

2587

2588

static void

2589

270

init_graphics_state (cairo_svg_glyph_render_t *svg_render)

2590

2591

    cairo_svg_graphics_state_t *gs;

2592

2593

270

    gs = _cairo_calloc (sizeof (cairo_svg_graphics_state_t));

2594

270

    get_paint (svg_render, "black", &gs->fill);

2595

270

    get_paint (svg_render, "none", &gs->stroke);

2596

270

    gs->color.type = FOREGROUND;

2597

270

    gs->fill_opacity = 1.0;

2598

270

    gs->stroke_opacity = 1.0;

2599

270

    gs->opacity = 1.0;

2600

270

    gs->fill_rule = CAIRO_FILL_RULE_WINDING;

2601

270

    gs->clip_rule = CAIRO_FILL_RULE_WINDING;

2602

270

    gs->clip_path = NULL;

2603

270

    gs->dash_array = NULL;

2604

270

    gs->dash_offset = 0.0;

2605

270

    gs->mode = GS_RENDER;

2606

270

    gs->bbox.x = 0;

2607

270

    gs->bbox.y = 0;

2608

270

    gs->bbox.width = 0;

2609

270

    gs->bbox.height = 0;

2610

270

    gs->next = NULL;

2611

2612

270

    svg_render->graphics_state = gs;

2613

2614

270

    cairo_save (svg_render->cr);

2615

270

    cairo_set_source_rgb (svg_render->cr, 0, 0, 0);

2616

270

    cairo_set_line_width (svg_render->cr, 1.0);

2617

270

    cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_BUTT);

2618

270

    cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_MITER);

2619

270

    cairo_set_miter_limit (svg_render->cr, 4.0);

2620

270

2621

2622

#define MAX_DASHES 100

2623

1164

static void update_dash (cairo_svg_glyph_render_t *svg_render,

2624

                         cairo_svg_element_t      *element)

2625

2626

1164

    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

2627

    const char *p;

2628

    char *end;

2629

    double value;

2630

    double dash_array[MAX_DASHES];

2631

1164

    int num_dashes = 0;

2632

1164

    cairo_bool_t not_zero = FALSE;

2633

2634

1164

    if (gs->dash_array == NULL || string_equal (gs->dash_array, "none")) {

2635

1140

        cairo_set_dash (svg_render->cr, NULL, 0, 0);

2636

1140

        return;

2637

2638

2639

24

    p = gs->dash_array;

2640

84

    while (*p && num_dashes < MAX_DASHES) {

2641

96

        while (*p && (*p == ',' || _cairo_isspace (*p)))

2642

36

            p++;

2643

2644

60

        if (*p == 0)

2645

            break;

2646

2647

60

        value = _cairo_strtod (p, &end);

2648

60

        if (end == p)

2649

            break;

2650

2651

60

        p = end;

2652

60

        if (*p == '%') {

2653

            value *= svg_render->width / 100.0;

2654

            p++;

2655

2656

2657

60

        if (value < 0.0)

2658

            return;

2659

2660

60

        if (value > 0.0)

2661

60

            not_zero = TRUE;

2662

2663

60

        dash_array[num_dashes++] = value;

2664

2665

2666

24

    if (not_zero)

2667

24

        cairo_set_dash (svg_render->cr, dash_array, num_dashes, gs->dash_offset);

2668

2669

2670

static cairo_bool_t

2671

231

pattern_requires_bbox (cairo_svg_glyph_render_t *svg_render,

2672

                       cairo_svg_element_t      *paint_server)

2673

2674

    const char *p;

2675

2676

354

    if (string_equal (paint_server->tag, "linearGradient") ||

2677

123

        string_equal (paint_server->tag, "radialGradient"))

2678

2679

231

        p = get_attribute (paint_server, "gradientUnits");

2680

231

        if (string_equal (p, "userSpaceOnUse"))

2681

39

            return FALSE;

2682

2683

192

        return TRUE;

2684

2685

    return FALSE;

2686

2687

2688

static cairo_bool_t

2689

1110

clip_requires_bbox (cairo_svg_glyph_render_t *svg_render,

2690

                    const char               *clip_path)

2691

2692

    cairo_svg_element_t *element;

2693

    const char *p;

2694

2695

1110

    if (clip_path && strncmp (clip_path, "url", 3) == 0) {

2696

24

        element = lookup_url_element (svg_render, clip_path);

2697

24

        if (element) {

2698

24

            p = get_attribute (element, "clipPathUnits");

2699

24

            if (string_equal (p, "objectBoundingBox"))

2700

12

                return TRUE;

2701

2702

2703

1098

    return FALSE;

2704

2705

2706

static cairo_bool_t

2707

1110

need_bbox (cairo_svg_glyph_render_t *svg_render,

2708

           cairo_svg_element_t      *element)

2709

2710

1110

    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

2711

1110

    cairo_bool_t fill_needs_bbox = FALSE;

2712

1110

    cairo_bool_t stroke_needs_bbox = FALSE;

2713

1110

    cairo_bool_t clip_needs_bbox = FALSE;

2714

2715

1110

    if (gs->mode != GS_RENDER)

2716

        return FALSE;

2717

2718

1110

    if (gs->fill.type == PAINT_SERVER && pattern_requires_bbox (svg_render, gs->fill.paint_server))

2719

192

        fill_needs_bbox = TRUE;

2720

2721

1110

    if (gs->stroke.type == PAINT_SERVER && pattern_requires_bbox (svg_render, gs->stroke.paint_server))

2722

        stroke_needs_bbox = TRUE;

2723

2724

1110

    if (clip_requires_bbox (svg_render, get_attribute (element, "clip-path")))

2725

12

        clip_needs_bbox = TRUE;

2726

2727

2187

    if (string_equal (element->tag, "circle") ||

2728

2151

        string_equal (element->tag, "ellipse") ||

2729

2079

        string_equal (element->tag, "path") ||

2730

2001

        string_equal (element->tag, "polygon") ||

2731

996

        string_equal (element->tag, "rect"))

2732

2733

324

        return fill_needs_bbox || stroke_needs_bbox || clip_needs_bbox;

2734

2735

2736

1497

    if (string_equal (element->tag, "line") ||

2737

711

        string_equal (element->tag, "polyline"))

2738

2739

90

        return stroke_needs_bbox || clip_needs_bbox;

2740

2741

2742

1326

    if (string_equal (element->tag, "g") ||

2743

1254

        string_equal (element->tag, "image") ||

2744

624

        string_equal (element->tag, "use"))

2745

2746

144

        return clip_needs_bbox;

2747

2748

2749

552

    return FALSE;

2750

2751

2752

static cairo_bool_t

2753

call_element (cairo_svg_glyph_render_t *svg_render,

2754

              cairo_svg_element_t      *element,

2755

              cairo_bool_t              end_tag);

2756

2757

static void

2758

1167

update_graphics_state (cairo_svg_glyph_render_t *svg_render,

2759

                       cairo_svg_element_t      *element)

2760

2761

    double value;

2762

    const char *p;

2763

1167

    cairo_svg_graphics_state_t *gs = svg_render->graphics_state;

2764

2765

1167

    p = get_attribute (element, "transform");

2766

1167

    if (p) {

2767

        cairo_matrix_t m;

2768

117

        if (parse_transform (p, &m))

2769

117

            cairo_transform (svg_render->cr, &m);

2770

2771

2772

    /* The transform is all we need for bbox computation. The SVG spec

2773

     * excludes clipping and stroke-width from the bbox. */

2774

1167

    if (gs->mode == GS_COMPUTE_BBOX)

2775

3

        return;

2776

2777

1164

    p = get_attribute (element, "color");

2778

1164

    if (p)

2779

6

        get_color (svg_render, p, &gs->color);

2780

2781

1164

    if (!get_float_attribute (element, "opacity", &gs->opacity))

2782

1161

        gs->opacity = 1.0;

2783

2784

1164

    p = get_attribute (element, "fill");

2785

1164

    if (p) {

2786

246

        get_paint (svg_render, p, &gs->fill);

2787

2788

2789

1164

    get_float_attribute (element, "fill-opacity", &gs->fill_opacity);

2790

2791

1164

    gs->fill_rule = get_fill_rule_attribute (element, "fill-rule", gs->fill_rule);

2792

2793

1164

    gs->clip_rule = get_fill_rule_attribute (element, "fill-rule", gs->clip_rule);

2794

2795

1164

    p = get_attribute (element, "stroke");

2796

1164

    if (p)

2797

138

        get_paint (svg_render, p, &gs->stroke);

2798

2799

1164

    if (get_float_or_percent_attribute (element, "stroke-width", svg_render->width, &value))

2800

132

        cairo_set_line_width (svg_render->cr, value);

2801

2802

1164

    p = get_attribute (element, "stroke-linecap");

2803

1164

    if (string_equal (p, "butt"))

2804

3

        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_BUTT);

2805

1161

    else if (string_equal (p, "round"))

2806

3

        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_ROUND);

2807

1158

    else if (string_equal (p, "square"))

2808

3

        cairo_set_line_cap (svg_render->cr, CAIRO_LINE_CAP_SQUARE);

2809

2810

1164

    p = get_attribute (element, "stroke-linejoin");

2811

1164

    if (string_equal (p, "miter"))

2812

6

        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_MITER);

2813

1158

    else if (string_equal (p, "round"))

2814

3

        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_ROUND);

2815

1155

    else if (string_equal (p, "bevel"))

2816

3

        cairo_set_line_join (svg_render->cr, CAIRO_LINE_JOIN_BEVEL);

2817

2818

1164

    if (get_float_attribute (element, "stroke-miterlimit", &value))

2819

3

        cairo_set_miter_limit (svg_render->cr, value);

2820

2821

1164

    p = get_attribute (element, "stroke-dasharray");

2822

1164

    if (p) {

2823

30

        free (gs->dash_array);

2824

30

        gs->dash_array = strdup (p);

2825

2826

2827

1164

    get_float_or_percent_attribute (element, "stroke-dashoffset", svg_render->width, &gs->dash_offset);

2828

1164

    update_dash (svg_render, element);

2829

2830

    /* Some elements may need the bounding box of the element thay are

2831

     * applied to.  As this recursively calls render_element on the

2832

     * same element while we are in render_element and setting up the

2833

     * graphics state, we check gs->mode to avoid re-entering the

2834

     * compute bbox code. The GS_COMPUTE_MODE flag is also used by

2835

     * render functions to ignore patterns and strokes (SVG spec

2836

     * ignores stroke with in bbox calculations) and just use a solid

2837

     * color.

2838

*/

2839

1164

    if (gs->mode == GS_RENDER && need_bbox (svg_render, element)) {

2840

60

        cairo_surface_t *recording = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);

2841

60

        cairo_t *old_cr = svg_render->cr;

2842

60

        svg_render->cr = cairo_create (recording);

2843

60

        gs_mode_t old_mode = gs->mode;

2844

60

        gs->mode = GS_COMPUTE_BBOX;

2845

        /* To avoid recursing back into this function, we call the

2846

         * element directory then use render_element_tree to render

2847

         * the children */

2848

60

        call_element (svg_render, element, FALSE);

2849

60

        render_element_tree (svg_render, element, NULL, TRUE);

2850

60

        if (element->type == CONTAINER_ELEMENT)

2851

3

            call_element (svg_render, element, TRUE);

2852

60

        gs->mode = old_mode;

2853

60

        cairo_destroy (svg_render->cr);

2854

60

        svg_render->cr = old_cr;

2855

60

        cairo_recording_surface_ink_extents (recording,

2856

                                             &gs->bbox.x,

2857

                                             &gs->bbox.y,

2858

                                             &gs->bbox.width,

2859

                                             &gs->bbox.height);

2860

60

        cairo_surface_destroy (recording);

2861

2862

2863

    /* clip-path may require bbox */

2864

1164

    p = get_attribute (element, "clip-path");

2865

1164

    if (p && strncmp (p, "url", 3) == 0) {

2866

24

        element = lookup_url_element (svg_render, p);

2867

24

        if (element) {

2868

24

            gs_mode_t old_mode = gs->mode;

2869

24

            gs->mode = GS_CLIP;

2870

24

            render_element_tree (svg_render, element, NULL, FALSE);

2871

24

            cairo_set_fill_rule (svg_render->cr, gs->clip_rule);

2872

24

            cairo_clip (svg_render->cr);

2873

24

            gs->mode = old_mode;

2874

2875

2876

2877

2878

static void

2879

1167

save_graphics_state (cairo_svg_glyph_render_t *svg_render)

2880

2881

    cairo_svg_graphics_state_t *gs;

2882

2883

1167

    cairo_save (svg_render->cr);

2884

2885

1167

    gs = _cairo_calloc (sizeof (cairo_svg_graphics_state_t));

2886

1167

    gs->fill           = svg_render->graphics_state->fill;

2887

1167

    gs->stroke         = svg_render->graphics_state->stroke;

2888

1167

    gs->color          = svg_render->graphics_state->color;

2889

1167

    gs->fill_opacity   = svg_render->graphics_state->fill_opacity;

2890

1167

    gs->stroke_opacity = svg_render->graphics_state->stroke_opacity;

2891

1167

    gs->opacity        = svg_render->graphics_state->opacity;

2892

1167

    gs->fill_rule      = svg_render->graphics_state->fill_rule;

2893

1167

    gs->clip_rule      = svg_render->graphics_state->clip_rule;

2894

1167

    gs->clip_path      = NULL;

2895

1167

    gs->dash_array     = NULL;

2896

1167

    if (svg_render->graphics_state->dash_array)

2897

        gs->dash_array = strdup (svg_render->graphics_state->dash_array);

2898

1167

    gs->dash_offset    = svg_render->graphics_state->dash_offset;

2899

1167

    gs->mode           = svg_render->graphics_state->mode;

2900

1167

    gs->bbox           = svg_render->graphics_state->bbox;

2901

1167

    gs->next           = svg_render->graphics_state;

2902

1167

    svg_render->graphics_state = gs;

2903

1167

2904

2905

static void

2906

1437

restore_graphics_state (cairo_svg_glyph_render_t *svg_render)

2907

2908

    cairo_svg_graphics_state_t *gs;

2909

2910

1437

    gs = svg_render->graphics_state;

2911

1437

    svg_render->graphics_state = gs->next;

2912

1437

    if (gs->clip_path)

2913

        cairo_path_destroy (gs->clip_path);

2914

1437

    free (gs->dash_array);

2915

1437

    free (gs);

2916

2917

1437

    cairo_restore (svg_render->cr);

2918

1437

2919

2920

/* render function returns TRUE if render_element_tree() is to render

2921

 * the child nodes, FALSE if render_element_tree() is to skip the

2922

 * child nodes.

2923

*/

2924

struct render_func {

2925

    const char *tag;

2926

    cairo_bool_t (*render) (cairo_svg_glyph_render_t *, cairo_svg_element_t *, cairo_bool_t);

2927

};

2928

2929

/* Must be sorted */

2930

static const struct render_func render_funcs[] = {

2931

    { "circle", render_element_circle },

2932

    { "clipPath", render_element_clip_path },

2933

    { "defs", NULL },

2934

    { "desc", NULL },

2935

    { "ellipse", render_element_ellipse },

2936

    { "g", render_element_g },

2937

    { "image", render_element_image },

2938

    { "line", render_element_line },

2939

    { "linearGradient", render_element_linear_gradient },

2940

    { "metadata", NULL },

2941

    { "path", render_element_path },

2942

    { "polygon", render_element_polyline },

2943

    { "polyline", render_element_polyline },

2944

    { "radialGradient", render_element_radial_gradient },

2945

    { "rect", render_element_rect },

2946

    { "stop", render_element_stop },

2947

    { "svg", render_element_svg },

2948

    { "title", NULL },

2949

    { "use", render_element_use },

2950

};

2951

2952

static int

2953

5487

_render_func_compare (const void *a, const void *b)

2954

2955

5487

    const struct render_func *render_func_a = a;

2956

5487

    const struct render_func *render_func_b = b;

2957

2958

5487

    return strcmp (render_func_a->tag, render_func_b->tag);

2959

2960

2961

static cairo_bool_t

2962

1485

call_element (cairo_svg_glyph_render_t *svg_render,

2963

              cairo_svg_element_t      *element,

2964

              cairo_bool_t              end_tag)

2965

2966

    const struct render_func *func;

2967

    struct render_func key;

2968

1485

    cairo_bool_t recurse = FALSE;

2969

2970

1485

    key.tag = element->tag;

2971

1485

    key.render = NULL;

2972

1485

    func = bsearch (&key,

2973

                    render_funcs,

2974

                    ARRAY_LENGTH (render_funcs),

2975

                    sizeof (struct render_func),

2976

                    _render_func_compare);

2977

1485

    if (func) {

2978

1485

        if (func->render) {

2979

1317

            recurse = func->render (svg_render, element, end_tag);

2980

2981

    } else {

2982

        print_warning (svg_render, "Unsupported element: %s", element->tag);

2983

2984

2985

1485

    return recurse;

2986

2987

2988

static cairo_bool_t

2989

1692

render_element (cairo_svg_glyph_render_t *svg_render,

2990

                cairo_svg_element_t      *element,

2991

                cairo_bool_t              end_tag,

2992

                cairo_svg_element_t      *display_element)

2993

2994

1692

    cairo_bool_t recurse = FALSE;

2995

    cairo_svg_graphics_state_t *gs;

2996

2997

    /* Ignore elements if we have not seen "<svg>". Ignore

2998

      * "<svg>" if we have seen it */

2999

1692

    if (svg_render->view_port_set) {

3000

1422

        if (string_equal (element->tag, "svg"))

3001

270

            return FALSE;

3002

    } else {

3003

270

        if (!string_equal (element->tag, "svg"))

3004

            return FALSE;

3005

3006

3007

1422

    if (element->type == EMPTY_ELEMENT ||

3008

780

        (element->type == CONTAINER_ELEMENT && !end_tag))

3009

3010

1167

        save_graphics_state (svg_render);

3011

1167

        update_graphics_state (svg_render, element);

3012

3013

3014

1422

    gs = svg_render->graphics_state;

3015

1422

    if (gs->mode == GS_NO_RENDER && element == display_element)

3016

        gs->mode = GS_RENDER;

3017

3018

1422

    recurse = call_element (svg_render, element, end_tag);

3019

3020

1422

    if (element->type == EMPTY_ELEMENT ||

3021

780

        (element->type == CONTAINER_ELEMENT && end_tag))

3022

3023

897

        restore_graphics_state (svg_render);

3024

3025

3026

1422

    return recurse;

3027

3028

3029

#define MAX_DEPTH 100

3030

3031

static void

3032

1551

render_element_tree (cairo_svg_glyph_render_t *svg_render,

3033

                     cairo_svg_element_t      *element,

3034

                     cairo_svg_element_t      *display_element,

3035

                     cairo_bool_t              children_only)

3036

3037

1551

    if (!element)

3038

        return;

3039

3040

    /* Avoid circular references by limiting the number of recursive

3041

     * calls to this function. */

3042

1551

    if (svg_render->render_element_tree_depth > MAX_DEPTH)

3043

        return;

3044

3045

1551

    svg_render->render_element_tree_depth++;

3046

1551

    if (element->type == EMPTY_ELEMENT && !children_only) {

3047

642

        render_element (svg_render, element, FALSE, display_element);

3048

3049

909

    } else if (element->type == CONTAINER_ELEMENT) {

3050

        int num_elems;

3051

798

        cairo_bool_t recurse = TRUE;;

3052

3053

798

        if (!children_only)

3054

525

            recurse = render_element (svg_render, element, FALSE, display_element);

3055

3056

        /* We only render the children if the parent returned

3057

         * success. This is how we avoid rendering non display

3058

         * elements like gradients, <defs>, and anything not

3059

         * implemented. */

3060

798

        if (recurse) {

3061

690

            num_elems = _cairo_array_num_elements (&element->children);

3062

1758

            for (int i = 0; i < num_elems; i++) {

3063

                cairo_svg_element_t *child;

3064

1068

                _cairo_array_copy_element (&element->children, i, &child);

3065

1068

                render_element_tree (svg_render, child, display_element, FALSE);

3066

3067

3068

3069

798

        if (!children_only)

3070

525

            render_element (svg_render, element, TRUE, display_element);

3071

3072

1551

    svg_render->render_element_tree_depth--;

3073

3074

3075

static void

3076

270

render_element_tree_id (cairo_svg_glyph_render_t *svg_render,

3077

                        const char               *element_id)

3078

3079

270

    cairo_svg_element_t *glyph_element = NULL;

3080

3081

270

    if (element_id)

3082

        glyph_element = lookup_element (svg_render, element_id);

3083

3084

270

    if (glyph_element)

3085

        svg_render->graphics_state->mode = GS_NO_RENDER;

3086

    else

3087

270

        svg_render->graphics_state->mode = GS_RENDER;

3088

3089

270

    render_element_tree (svg_render, svg_render->tree, glyph_element, TRUE);

3090

270

3091

3092

cairo_status_t

3093

270

_cairo_render_svg_glyph (const char           *svg_document,

3094

                         unsigned long         first_glyph,

3095

                         unsigned long         last_glyph,

3096

                         unsigned long         glyph,

3097

                         double                units_per_em,

3098

                         FT_Color             *palette,

3099

                         int                   num_palette_entries,

3100

                         cairo_t              *cr,

3101

                         cairo_pattern_t      *foreground_source,

3102

			 cairo_bool_t         *foreground_source_used)

3103

3104

270

    cairo_status_t status = CAIRO_STATUS_SUCCESS;

3105

3106

270

    cairo_svg_glyph_render_t *svg_render = _cairo_calloc (sizeof (cairo_svg_glyph_render_t));

3107

270

    if (unlikely (svg_render == NULL))

3108

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

3109

3110

270

    svg_render->tree = NULL;

3111

270

    svg_render->ids = _cairo_hash_table_create (_element_id_equal);

3112

270

    if (unlikely (svg_render->ids == NULL)) {

3113

        free (svg_render);

3114

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

3115

3116

3117

270

    svg_render->debug = 0;

3118

270

    const char *s = getenv ("CAIRO_DEBUG_SVG_RENDER");

3119

270

    if (s) {

3120

        if (strlen (s) > 0)

3121

            svg_render->debug = atoi (s);

3122

        else

3123

            svg_render->debug = SVG_RENDER_ERROR;

3124

3125

3126

270

    svg_render->cr = cr;

3127

270

    svg_render->units_per_em = units_per_em;

3128

270

    svg_render->build_pattern.paint_server = NULL;

3129

270

    svg_render->build_pattern.pattern = NULL;

3130

270

    svg_render->build_pattern.type = BUILD_PATTERN_NONE;

3131

270

    svg_render->render_element_tree_depth = 0;

3132

270

    svg_render->view_port_set = FALSE;

3133

270

    svg_render->num_palette_entries = num_palette_entries;

3134

270

    svg_render->palette = palette;

3135

3136

270

    svg_render->foreground_marker = _cairo_pattern_create_foreground_marker ();

3137

270

    svg_render->foreground_source = cairo_pattern_reference (foreground_source);;

3138

270

    svg_render->foreground_source_used = FALSE;

3139

3140

270

    init_graphics_state (svg_render);

3141

3142

270

    print_info (svg_render, "Glyph ID: %ld", glyph);

3143

270

    print_info (svg_render, "Palette Entries: %d", num_palette_entries);

3144

270

    print_info (svg_render, "Units per EM: %f", units_per_em);

3145

270

    print_info (svg_render, "SVG Document:\n%s\n", svg_document);

3146

3147

    /* First parse elements into a tree and populate ids hash table */

3148

270

    if (!parse_svg (svg_render, svg_document)) {

3149

        print_error (svg_render, "Parse SVG document failed");

3150

        status = CAIRO_STATUS_SVG_FONT_ERROR;

3151

        goto cleanup;

3152

3153

3154

#if SVG_RENDER_PRINT_FUNCTIONS

3155

    printf("\nTREE\n");

3156

    if (svg_render->tree) {

3157

        print_element (svg_render->tree, TRUE, 0);

3158

        printf("\n");

3159

3160

#endif

3161

3162

    /* Next, render glyph */

3163

270

    if (first_glyph == last_glyph) {

3164

        /* Render whole document */

3165

270

        render_element_tree_id (svg_render, NULL);

3166

    } else {

3167

        /* Render element with id "glyphID" where ID is glyph number. */

3168

3169

        char glyph_id[30];

3170

        snprintf(glyph_id, sizeof(glyph_id), "#glyph%ld", glyph);

3171

        render_element_tree_id (svg_render, glyph_id);

3172

3173

3174

270

  cleanup:

3175

270

    if (svg_render->build_pattern.pattern)

3176

        cairo_pattern_destroy (svg_render->build_pattern.pattern);

3177

3178

270

    if (svg_render->tree)

3179

270

        free_elements (svg_render, svg_render->tree);

3180

3181

810

    while (svg_render->graphics_state)

3182

540

        restore_graphics_state (svg_render);

3183

3184

270

    cairo_pattern_destroy (svg_render->foreground_marker);

3185

270

    cairo_pattern_destroy (svg_render->foreground_source);

3186

270

    *foreground_source_used = svg_render->foreground_source_used;

3187

3188

    /* The hash entry for each element with an id is removed by

3189

     * free_elements() */

3190

270

    _cairo_hash_table_destroy (svg_render->ids);

3191

3192

270

    free (svg_render);

3193

3194

270

    return status;

3195

3196

3197

#ifdef DEBUG_SVG_RENDER

3198

3199

/**

3200

 * _cairo_debug_svg_render:

3201

3202

 * Debug function for cairo-svg-glyph-render.c. Allows invoking the renderer from outside

3203

 * cairo to test with SVG documents, and to facilitate comparison with librsvg rendering.

3204

 * The viewport is .

3205

3206

 * @cr: render target

3207

 * @svg_document: SVG Document

3208

 * @element: element within svg_document to render (eg "#glyph8"), or NULL to render entire document.

3209

 * @debug_level: 0 - quiet, 1 - print errors, 2 - print warnings, 3 - info

3210

 * @return TRUE on success, ie no errors, FALSE if error

3211

**/

3212

cairo_public cairo_bool_t

3213

_cairo_debug_svg_render (cairo_t       *cr,

3214

                         const char    *svg_document,

3215

                         const char    *element,

3216

                         double         units_per_em,

3217

                         int            debug_level);

3218

3219

cairo_bool_t

3220

_cairo_debug_svg_render (cairo_t       *cr,

3221

                         const char    *svg_document,

3222

                         const char    *element,

3223

                         double         units_per_em,

3224

                         int            debug_level)

3225

3226

    cairo_status_t status;

3227

    cairo_bool_t foreground_source_used;

3228

    cairo_pattern_t *foreground = _cairo_pattern_create_foreground_marker ();

3229

3230

    status = _cairo_render_svg_glyph (svg_document,

3231

				      1, 1, 1,

3232

				      units_per_em,

3233

				      NULL, 0,

3234

cr,

3235

				      foreground,

3236

				      &foreground_source_used);

3237

    cairo_pattern_destroy (foreground);

3238

3239

    return status == CAIRO_STATUS_SUCCESS;

3240

3241

3242

#endif /* DEBUG_SVG_RENDER */

3243

3244

#endif /* HAVE_FT_SVG_DOCUMENT */