Grcov report - cairo-gstate.c

1

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

2

3

 * Copyright © 2002 University of Southern California

4

 * Copyright © 2005 Red Hat, Inc.

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 University of Southern

32

 * California.

33

34

 * Contributor(s):

35

 *	Carl D. Worth <cworth@cworth.org>

36

*/

37

38

#include "cairoint.h"

39

40

#include "cairo-clip-inline.h"

41

#include "cairo-clip-private.h"

42

#include "cairo-error-private.h"

43

#include "cairo-list-inline.h"

44

#include "cairo-gstate-private.h"

45

#include "cairo-pattern-private.h"

46

#include "cairo-traps-private.h"

47

48

static cairo_status_t

49

_cairo_gstate_init_copy (cairo_gstate_t *gstate, cairo_gstate_t *other);

50

51

static cairo_status_t

52

_cairo_gstate_ensure_font_face (cairo_gstate_t *gstate);

53

54

static cairo_status_t

55

_cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate);

56

57

static void

58

_cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate);

59

60

static void

61

_cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t      *gstate,

62

                                           const cairo_glyph_t *glyphs,

63

                                           int                  num_glyphs,

64

					   const cairo_text_cluster_t	*clusters,

65

					   int			 num_clusters,

66

					   cairo_text_cluster_flags_t cluster_flags,

67

                                           cairo_glyph_t       *transformed_glyphs,

68

					   int			*num_transformed_glyphs,

69

					   cairo_text_cluster_t *transformed_clusters,

70

					   cairo_bool_t          perform_early_clip);

71

72

static void

73

12

_cairo_gstate_update_device_transform (cairo_observer_t *observer,

74

				       void *arg)

75

76

12

    cairo_gstate_t *gstate = cairo_container_of (observer,

77

						 cairo_gstate_t,

78

						 device_transform_observer);

79

80

24

    gstate->is_identity = (_cairo_matrix_is_identity (&gstate->ctm) &&

81

12

			   _cairo_matrix_is_identity (&gstate->target->device_transform));

82

12

83

84

cairo_status_t

85

34933

_cairo_gstate_init (cairo_gstate_t  *gstate,

86

		    cairo_surface_t *target)

87

88

    VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));

89

90

34933

    gstate->next = NULL;

91

92

34933

    gstate->op = CAIRO_GSTATE_OPERATOR_DEFAULT;

93

34933

    gstate->opacity = 1.;

94

95

34933

    gstate->tolerance = CAIRO_GSTATE_TOLERANCE_DEFAULT;

96

34933

    gstate->antialias = CAIRO_ANTIALIAS_DEFAULT;

97

98

34933

    _cairo_stroke_style_init (&gstate->stroke_style);

99

100

34933

    gstate->fill_rule = CAIRO_GSTATE_FILL_RULE_DEFAULT;

101

102

34933

    gstate->font_face = NULL;

103

34933

    gstate->scaled_font = NULL;

104

34933

    gstate->previous_scaled_font = NULL;

105

106

34933

    cairo_matrix_init_scale (&gstate->font_matrix,

107

			     CAIRO_GSTATE_DEFAULT_FONT_SIZE,

108

			     CAIRO_GSTATE_DEFAULT_FONT_SIZE);

109

110

34933

    _cairo_font_options_init_default (&gstate->font_options);

111

112

34933

    gstate->clip = NULL;

113

114

34933

    gstate->target = cairo_surface_reference (target);

115

34933

    gstate->parent_target = NULL;

116

34933

    gstate->original_target = cairo_surface_reference (target);

117

118

34933

    gstate->device_transform_observer.callback = _cairo_gstate_update_device_transform;

119

34933

    cairo_list_add (&gstate->device_transform_observer.link,

120

34933

		    &gstate->target->device_transform_observers);

121

122

34933

    gstate->is_identity = _cairo_matrix_is_identity (&gstate->target->device_transform);

123

34933

    cairo_matrix_init_identity (&gstate->ctm);

124

34933

    gstate->ctm_inverse = gstate->ctm;

125

34933

    gstate->source_ctm_inverse = gstate->ctm;

126

127

34933

    gstate->source = (cairo_pattern_t *) &_cairo_pattern_black.base;

128

129

    /* Now that the gstate is fully initialized and ready for the eventual

130

     * _cairo_gstate_fini(), we can check for errors (and not worry about

131

     * the resource deallocation). */

132

34933

    return target->status;

133

134

135

/**

136

 * _cairo_gstate_init_copy:

137

138

 * Initialize @gstate by performing a deep copy of state fields from

139

 * @other. Note that gstate->next is not copied but is set to %NULL by

140

 * this function.

141

**/

142

static cairo_status_t

143

65888

_cairo_gstate_init_copy (cairo_gstate_t *gstate, cairo_gstate_t *other)

144

145

    cairo_status_t status;

146

147

    VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));

148

149

65888

    gstate->op = other->op;

150

65888

    gstate->opacity = other->opacity;

151

152

65888

    gstate->tolerance = other->tolerance;

153

65888

    gstate->antialias = other->antialias;

154

155

65888

    status = _cairo_stroke_style_init_copy (&gstate->stroke_style,

156

65888

					    &other->stroke_style);

157

65888

    if (unlikely (status))

158

	return status;

159

160

65888

    gstate->fill_rule = other->fill_rule;

161

162

65888

    gstate->font_face = cairo_font_face_reference (other->font_face);

163

65888

    gstate->scaled_font = cairo_scaled_font_reference (other->scaled_font);

164

65888

    gstate->previous_scaled_font = cairo_scaled_font_reference (other->previous_scaled_font);

165

166

65888

    gstate->font_matrix = other->font_matrix;

167

168

65888

    _cairo_font_options_init_copy (&gstate->font_options , &other->font_options);

169

170

65888

    gstate->clip = _cairo_clip_copy (other->clip);

171

172

65888

    gstate->target = cairo_surface_reference (other->target);

173

    /* parent_target is always set to NULL; it's only ever set by redirect_target */

174

65888

    gstate->parent_target = NULL;

175

65888

    gstate->original_target = cairo_surface_reference (other->original_target);

176

177

65888

    gstate->device_transform_observer.callback = _cairo_gstate_update_device_transform;

178

65888

    cairo_list_add (&gstate->device_transform_observer.link,

179

65888

		    &gstate->target->device_transform_observers);

180

181

65888

    gstate->is_identity = other->is_identity;

182

65888

    gstate->ctm = other->ctm;

183

65888

    gstate->ctm_inverse = other->ctm_inverse;

184

65888

    gstate->source_ctm_inverse = other->source_ctm_inverse;

185

186

65888

    gstate->source = cairo_pattern_reference (other->source);

187

188

65888

    gstate->next = NULL;

189

190

65888

    return CAIRO_STATUS_SUCCESS;

191

192

193

void

194

100815

_cairo_gstate_fini (cairo_gstate_t *gstate)

195

196

100815

    _cairo_stroke_style_fini (&gstate->stroke_style);

197

100815

    _cairo_font_options_fini (&gstate->font_options);

198

199

100815

    cairo_font_face_destroy (gstate->font_face);

200

100815

    gstate->font_face = NULL;

201

202

100815

    cairo_scaled_font_destroy (gstate->previous_scaled_font);

203

100815

    gstate->previous_scaled_font = NULL;

204

205

100815

    cairo_scaled_font_destroy (gstate->scaled_font);

206

100815

    gstate->scaled_font = NULL;

207

208

100815

    _cairo_clip_destroy (gstate->clip);

209

210

100815

    cairo_list_del (&gstate->device_transform_observer.link);

211

212

100815

    cairo_surface_destroy (gstate->target);

213

100815

    gstate->target = NULL;

214

215

100815

    cairo_surface_destroy (gstate->parent_target);

216

100815

    gstate->parent_target = NULL;

217

218

100815

    cairo_surface_destroy (gstate->original_target);

219

100815

    gstate->original_target = NULL;

220

221

100815

    cairo_pattern_destroy (gstate->source);

222

100815

    gstate->source = NULL;

223

224

    VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));

225

100815

226

227

/**

228

 * _cairo_gstate_save:

229

 * @gstate: input/output gstate pointer

230

231

 * Makes a copy of the current state of @gstate and saves it

232

 * to @gstate->next, then put the address of the newly allcated

233

 * copy into @gstate.  _cairo_gstate_restore() reverses this.

234

**/

235

cairo_status_t

236

65888

_cairo_gstate_save (cairo_gstate_t **gstate, cairo_gstate_t **freelist)

237

238

    cairo_gstate_t *top;

239

    cairo_status_t status;

240

241

    if (CAIRO_INJECT_FAULT ())

242

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

243

244

65888

    top = *freelist;

245

65888

    if (top == NULL) {

246

1551

	top = _cairo_calloc (sizeof (cairo_gstate_t));

247

1551

	if (unlikely (top == NULL))

248

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

249

    } else

250

64337

	*freelist = top->next;

251

252

65888

    status = _cairo_gstate_init_copy (top, *gstate);

253

65888

    if (unlikely (status)) {

254

	top->next = *freelist;

255

	*freelist = top;

256

	return status;

257

258

259

65888

    top->next = *gstate;

260

65888

    *gstate = top;

261

262

65888

    return CAIRO_STATUS_SUCCESS;

263

264

265

/**

266

 * _cairo_gstate_restore:

267

 * @gstate: input/output gstate pointer

268

269

 * Reverses the effects of one _cairo_gstate_save() call.

270

**/

271

cairo_status_t

272

65891

_cairo_gstate_restore (cairo_gstate_t **gstate, cairo_gstate_t **freelist)

273

274

    cairo_gstate_t *top;

275

276

65891

    top = *gstate;

277

65891

    if (top->next == NULL)

278

3

	return _cairo_error (CAIRO_STATUS_INVALID_RESTORE);

279

280

65888

    *gstate = top->next;

281

282

65888

    _cairo_gstate_fini (top);

283

    VG (VALGRIND_MAKE_MEM_UNDEFINED (&top->next, sizeof (cairo_gstate_t *)));

284

65888

    top->next = *freelist;

285

65888

    *freelist = top;

286

287

65888

    return CAIRO_STATUS_SUCCESS;

288

289

290

/**

291

 * _cairo_gstate_redirect_target:

292

 * @gstate: a #cairo_gstate_t

293

 * @child: the new child target

294

295

 * Redirect @gstate rendering to a "child" target. The original

296

 * "parent" target with which the gstate was created will not be

297

 * affected. See _cairo_gstate_get_target().

298

**/

299

cairo_status_t

300

647

_cairo_gstate_redirect_target (cairo_gstate_t *gstate, cairo_surface_t *child)

301

302

    /* If this gstate is already redirected, this is an error; we need a

303

     * new gstate to be able to redirect */

304

647

    assert (gstate->parent_target == NULL);

305

306

    /* Set up our new parent_target based on our current target;

307

     * gstate->parent_target will take the ref that is held by gstate->target

308

*/

309

647

    gstate->parent_target = gstate->target;

310

311

    /* Now set up our new target; we overwrite gstate->target directly,

312

     * since its ref is now owned by gstate->parent_target */

313

647

    gstate->target = cairo_surface_reference (child);

314

647

    gstate->is_identity &= _cairo_matrix_is_identity (&child->device_transform);

315

647

    cairo_list_move (&gstate->device_transform_observer.link,

316

647

		     &gstate->target->device_transform_observers);

317

318

    /* The clip is in surface backend coordinates for the previous target;

319

     * translate it into the child's backend coordinates. */

320

647

    _cairo_clip_destroy (gstate->clip);

321

1294

    gstate->clip = _cairo_clip_copy_with_translation (gstate->next->clip,

322

647

						      child->device_transform.x0 - gstate->parent_target->device_transform.x0,

323

647

						      child->device_transform.y0 - gstate->parent_target->device_transform.y0);

324

325

647

    return CAIRO_STATUS_SUCCESS;

326

327

328

/**

329

 * _cairo_gstate_is_group:

330

 * @gstate: a #cairo_gstate_t

331

332

 * Check if _cairo_gstate_redirect_target has been called on the head

333

 * of the stack.

334

335

 * Return value: %TRUE if @gstate is redirected to a target different

336

 * than the previous state in the stack, %FALSE otherwise.

337

**/

338

cairo_bool_t

339

65885

_cairo_gstate_is_group (cairo_gstate_t *gstate)

340

341

65885

    return gstate->parent_target != NULL;

342

343

344

/**

345

 * _cairo_gstate_get_target:

346

 * @gstate: a #cairo_gstate_t

347

348

 * Return the current drawing target; if drawing is not redirected,

349

 * this will be the same as _cairo_gstate_get_original_target().

350

351

 * Return value: the current target surface

352

**/

353

cairo_surface_t *

354

2474

_cairo_gstate_get_target (cairo_gstate_t *gstate)

355

356

2474

    return gstate->target;

357

358

359

/**

360

 * _cairo_gstate_get_original_target:

361

 * @gstate: a #cairo_gstate_t

362

363

 * Return the original target with which @gstate was created. This

364

 * function always returns the original target independent of any

365

 * child target that may have been set with

366

 * _cairo_gstate_redirect_target.

367

368

 * Return value: the original target surface

369

**/

370

cairo_surface_t *

371

47993

_cairo_gstate_get_original_target (cairo_gstate_t *gstate)

372

373

47993

    return gstate->original_target;

374

375

376

/**

377

 * _cairo_gstate_get_clip:

378

 * @gstate: a #cairo_gstate_t

379

380

 * This space left intentionally blank.

381

382

 * Return value: a pointer to the gstate's #cairo_clip_t structure.

383

**/

384

cairo_clip_t *

385

659

_cairo_gstate_get_clip (cairo_gstate_t *gstate)

386

387

659

    return gstate->clip;

388

389

390

cairo_status_t

391

249550

_cairo_gstate_set_source (cairo_gstate_t  *gstate,

392

			  cairo_pattern_t *source)

393

394

249550

    if (source->status)

395

	return source->status;

396

397

249550

    source = cairo_pattern_reference (source);

398

249550

    cairo_pattern_destroy (gstate->source);

399

249550

    gstate->source = source;

400

249550

    gstate->source_ctm_inverse = gstate->ctm_inverse;

401

402

249550

    return CAIRO_STATUS_SUCCESS;

403

404

405

cairo_pattern_t *

406

33861

_cairo_gstate_get_source (cairo_gstate_t *gstate)

407

408

33861

    if (gstate->source == &_cairo_pattern_black.base) {

409

	/* do not expose the static object to the user */

410

1506

        gstate->source = _cairo_pattern_create_solid (CAIRO_COLOR_BLACK);

411

412

413

33861

    return gstate->source;

414

415

416

cairo_status_t

417

5520

_cairo_gstate_set_operator (cairo_gstate_t *gstate, cairo_operator_t op)

418

419

5520

    gstate->op = op;

420

421

5520

    return CAIRO_STATUS_SUCCESS;

422

423

424

cairo_operator_t

425

12

_cairo_gstate_get_operator (cairo_gstate_t *gstate)

426

427

12

    return gstate->op;

428

429

430

cairo_status_t

431

_cairo_gstate_set_opacity (cairo_gstate_t *gstate, double op)

432

433

    gstate->opacity = op;

434

435

    return CAIRO_STATUS_SUCCESS;

436

437

438

double

439

_cairo_gstate_get_opacity (cairo_gstate_t *gstate)

440

441

    return gstate->opacity;

442

443

444

cairo_status_t

445

501

_cairo_gstate_set_tolerance (cairo_gstate_t *gstate, double tolerance)

446

447

501

    gstate->tolerance = tolerance;

448

449

501

    return CAIRO_STATUS_SUCCESS;

450

451

452

double

453

495400

_cairo_gstate_get_tolerance (cairo_gstate_t *gstate)

454

455

495400

    return gstate->tolerance;

456

457

458

cairo_status_t

459

902

_cairo_gstate_set_fill_rule (cairo_gstate_t *gstate, cairo_fill_rule_t fill_rule)

460

461

902

    gstate->fill_rule = fill_rule;

462

463

902

    return CAIRO_STATUS_SUCCESS;

464

465

466

cairo_fill_rule_t

467

21

_cairo_gstate_get_fill_rule (cairo_gstate_t *gstate)

468

469

21

    return gstate->fill_rule;

470

471

472

cairo_status_t

473

3705

_cairo_gstate_set_line_width (cairo_gstate_t *gstate, double width)

474

475

3705

    if (gstate->stroke_style.is_hairline)

476

15

	gstate->stroke_style.pre_hairline_line_width = width;

477

	else

478

3690

	gstate->stroke_style.line_width = width;

479

480

3705

    return CAIRO_STATUS_SUCCESS;

481

482

483

double

484

29259705

_cairo_gstate_get_line_width (cairo_gstate_t *gstate)

485

486

29259705

    return gstate->stroke_style.line_width;

487

488

489

cairo_status_t

490

30

_cairo_gstate_set_hairline (cairo_gstate_t *gstate, cairo_bool_t set_hairline)

491

492

30

    if (gstate->stroke_style.is_hairline != set_hairline) {

493

30

        gstate->stroke_style.is_hairline = set_hairline;

494

495

30

        if (set_hairline) {

496

15

            gstate->stroke_style.pre_hairline_line_width = gstate->stroke_style.line_width;

497

15

            gstate->stroke_style.line_width = 0.0;

498

        } else {

499

15

            gstate->stroke_style.line_width = gstate->stroke_style.pre_hairline_line_width;

500

501

502

503

30

    return CAIRO_STATUS_SUCCESS;

504

505

506

cairo_bool_t

507

45

_cairo_gstate_get_hairline (cairo_gstate_t *gstate)

508

509

45

    return gstate->stroke_style.is_hairline;

510

511

512

cairo_status_t

513

2598

_cairo_gstate_set_line_cap (cairo_gstate_t *gstate, cairo_line_cap_t line_cap)

514

515

2598

    gstate->stroke_style.line_cap = line_cap;

516

517

2598

    return CAIRO_STATUS_SUCCESS;

518

519

520

cairo_line_cap_t

521

12

_cairo_gstate_get_line_cap (cairo_gstate_t *gstate)

522

523

12

    return gstate->stroke_style.line_cap;

524

525

526

cairo_status_t

527

1527

_cairo_gstate_set_line_join (cairo_gstate_t *gstate, cairo_line_join_t line_join)

528

529

1527

    gstate->stroke_style.line_join = line_join;

530

531

1527

    return CAIRO_STATUS_SUCCESS;

532

533

534

cairo_line_join_t

535

12

_cairo_gstate_get_line_join (cairo_gstate_t *gstate)

536

537

12

    return gstate->stroke_style.line_join;

538

539

540

cairo_status_t

541

3000

_cairo_gstate_set_dash (cairo_gstate_t *gstate, const double *dash, int num_dashes, double offset)

542

543

    double dash_total, on_total, off_total;

544

    int i, j;

545

546

3000

    free (gstate->stroke_style.dash);

547

548

3000

    gstate->stroke_style.num_dashes = num_dashes;

549

550

3000

    if (gstate->stroke_style.num_dashes == 0) {

551

1767

	gstate->stroke_style.dash = NULL;

552

1767

	gstate->stroke_style.dash_offset = 0.0;

553

1767

	return CAIRO_STATUS_SUCCESS;

554

555

556

1233

    gstate->stroke_style.dash = _cairo_malloc_ab (gstate->stroke_style.num_dashes, sizeof (double));

557

1233

    if (unlikely (gstate->stroke_style.dash == NULL)) {

558

	gstate->stroke_style.num_dashes = 0;

559

	return _cairo_error (CAIRO_STATUS_NO_MEMORY);

560

561

562

1233

    on_total = off_total = dash_total = 0.0;

563

4131

    for (i = j = 0; i < num_dashes; i++) {

564

2898

	if (dash[i] < 0)

565

	    return _cairo_error (CAIRO_STATUS_INVALID_DASH);

566

567

2898

	if (dash[i] == 0 && i > 0 && i < num_dashes - 1) {

568

42

	    if (dash[++i] < 0)

569

		return _cairo_error (CAIRO_STATUS_INVALID_DASH);

570

571

42

	    gstate->stroke_style.dash[j-1] += dash[i];

572

42

	    gstate->stroke_style.num_dashes -= 2;

573

	} else

574

2856

	    gstate->stroke_style.dash[j++] = dash[i];

575

576

2898

	if (dash[i]) {

577

2832

	    dash_total += dash[i];

578

2832

	    if ((i & 1) == 0)

579

1524

		on_total += dash[i];

580

	    else

581

1308

		off_total += dash[i];

582

583

584

585

1233

    if (dash_total == 0.0)

586

	return _cairo_error (CAIRO_STATUS_INVALID_DASH);

587

588

    /* An odd dash value indicate symmetric repeating, so the total

589

     * is twice as long. */

590

1233

    if (gstate->stroke_style.num_dashes & 1) {

591

210

	dash_total *= 2;

592

210

	on_total += off_total;

593

594

595

1233

    if (dash_total - on_total < CAIRO_FIXED_ERROR_DOUBLE) {

596

	/* Degenerate dash -> solid line */

597

27

	free (gstate->stroke_style.dash);

598

27

	gstate->stroke_style.dash = NULL;

599

27

	gstate->stroke_style.num_dashes = 0;

600

27

	gstate->stroke_style.dash_offset = 0.0;

601

27

	return CAIRO_STATUS_SUCCESS;

602

603

604

    /* The dashing code doesn't like a negative offset or a big positive

605

     * offset, so we compute an equivalent offset which is guaranteed to be

606

     * positive and less than twice the pattern length. */

607

1206

    offset = fmod (offset, dash_total);

608

1206

    if (offset < 0.0)

609

69

	offset += dash_total;

610

1206

    if (offset <= 0.0)		/* Take care of -0 */

611

462

	offset = 0.0;

612

1206

    gstate->stroke_style.dash_offset = offset;

613

614

1206

    return CAIRO_STATUS_SUCCESS;

615

616

617

void

618

24

_cairo_gstate_get_dash (cairo_gstate_t *gstate,

619

			double         *dashes,

620

			int            *num_dashes,

621

			double         *offset)

622

623

24

    if (dashes) {

624

12

	memcpy (dashes,

625

12

		gstate->stroke_style.dash,

626

12

		sizeof (double) * gstate->stroke_style.num_dashes);

627

628

629

24

    if (num_dashes)

630

12

	*num_dashes = gstate->stroke_style.num_dashes;

631

632

24

    if (offset)

633

12

	*offset = gstate->stroke_style.dash_offset;

634

24

635

636

cairo_status_t

637

297

_cairo_gstate_set_miter_limit (cairo_gstate_t *gstate, double limit)

638

639

297

    gstate->stroke_style.miter_limit = limit;

640

641

297

    return CAIRO_STATUS_SUCCESS;

642

643

644

double

645

12

_cairo_gstate_get_miter_limit (cairo_gstate_t *gstate)

646

647

12

    return gstate->stroke_style.miter_limit;

648

649

650

void

651

495448

_cairo_gstate_get_matrix (cairo_gstate_t *gstate, cairo_matrix_t *matrix)

652

653

495448

    *matrix = gstate->ctm;

654

495448

655

656

cairo_status_t

657

59541

_cairo_gstate_translate (cairo_gstate_t *gstate, double tx, double ty)

658

659

    cairo_matrix_t tmp;

660

661

59541

    if (! ISFINITE (tx) || ! ISFINITE (ty))

662

18

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

663

664

59523

    _cairo_gstate_unset_scaled_font (gstate);

665

666

59523

    cairo_matrix_init_translate (&tmp, tx, ty);

667

59523

    cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);

668

59523

    gstate->is_identity = FALSE;

669

670

    /* paranoid check against gradual numerical instability */

671

59523

    if (! _cairo_matrix_is_invertible (&gstate->ctm))

672

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

673

674

59523

    cairo_matrix_init_translate (&tmp, -tx, -ty);

675

59523

    cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);

676

677

59523

    return CAIRO_STATUS_SUCCESS;

678

679

680

cairo_status_t

681

3092

_cairo_gstate_scale (cairo_gstate_t *gstate, double sx, double sy)

682

683

    cairo_matrix_t tmp;

684

685

3092

    if (sx * sy == 0.) /* either sx or sy is 0, or det == 0 due to underflow */

686

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

687

3092

    if (! ISFINITE (sx) || ! ISFINITE (sy))

688

27

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

689

690

3065

    _cairo_gstate_unset_scaled_font (gstate);

691

692

3065

    cairo_matrix_init_scale (&tmp, sx, sy);

693

3065

    cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);

694

3065

    gstate->is_identity = FALSE;

695

696

    /* paranoid check against gradual numerical instability */

697

3065

    if (! _cairo_matrix_is_invertible (&gstate->ctm))

698

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

699

700

3065

    cairo_matrix_init_scale (&tmp, 1/sx, 1/sy);

701

3065

    cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);

702

703

3065

    return CAIRO_STATUS_SUCCESS;

704

705

706

cairo_status_t

707

901

_cairo_gstate_rotate (cairo_gstate_t *gstate, double angle)

708

709

    cairo_matrix_t tmp;

710

711

901

    if (angle == 0.)

712

48

	return CAIRO_STATUS_SUCCESS;

713

714

853

    if (! ISFINITE (angle))

715

6

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

716

717

847

    _cairo_gstate_unset_scaled_font (gstate);

718

719

847

    cairo_matrix_init_rotate (&tmp, angle);

720

847

    cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);

721

847

    gstate->is_identity = FALSE;

722

723

    /* paranoid check against gradual numerical instability */

724

847

    if (! _cairo_matrix_is_invertible (&gstate->ctm))

725

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

726

727

847

    cairo_matrix_init_rotate (&tmp, -angle);

728

847

    cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);

729

730

847

    return CAIRO_STATUS_SUCCESS;

731

732

733

cairo_status_t

734

276

_cairo_gstate_transform (cairo_gstate_t	      *gstate,

735

			 const cairo_matrix_t *matrix)

736

737

    cairo_matrix_t tmp;

738

    cairo_status_t status;

739

740

276

    if (! _cairo_matrix_is_invertible (matrix))

741

9

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

742

743

267

    if (_cairo_matrix_is_identity (matrix))

744

30

	return CAIRO_STATUS_SUCCESS;

745

746

237

    tmp = *matrix;

747

237

    status = cairo_matrix_invert (&tmp);

748

237

    if (unlikely (status))

749

	return status;

750

751

237

    _cairo_gstate_unset_scaled_font (gstate);

752

753

237

    cairo_matrix_multiply (&gstate->ctm, matrix, &gstate->ctm);

754

237

    cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);

755

237

    gstate->is_identity = FALSE;

756

757

    /* paranoid check against gradual numerical instability */

758

237

    if (! _cairo_matrix_is_invertible (&gstate->ctm))

759

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

760

761

237

    return CAIRO_STATUS_SUCCESS;

762

763

764

cairo_status_t

765

1338

_cairo_gstate_set_matrix (cairo_gstate_t       *gstate,

766

			  const cairo_matrix_t *matrix)

767

768

    cairo_status_t status;

769

770

1338

    if (memcmp (matrix, &gstate->ctm, sizeof (cairo_matrix_t)) == 0)

771

27

	return CAIRO_STATUS_SUCCESS;

772

773

1311

    if (! _cairo_matrix_is_invertible (matrix))

774

9

	return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);

775

776

1302

    if (_cairo_matrix_is_identity (matrix)) {

777

24

	_cairo_gstate_identity_matrix (gstate);

778

24

	return CAIRO_STATUS_SUCCESS;

779

780

781

1278

    _cairo_gstate_unset_scaled_font (gstate);

782

783

1278

    gstate->ctm = *matrix;

784

1278

    gstate->ctm_inverse = *matrix;

785

1278

    status = cairo_matrix_invert (&gstate->ctm_inverse);

786

1278

    assert (status == CAIRO_STATUS_SUCCESS);

787

1278

    gstate->is_identity = FALSE;

788

789

1278

    return CAIRO_STATUS_SUCCESS;

790

791

792

void

793

84

_cairo_gstate_identity_matrix (cairo_gstate_t *gstate)

794

795

84

    if (_cairo_matrix_is_identity (&gstate->ctm))

796

6

	return;

797

798

78

    _cairo_gstate_unset_scaled_font (gstate);

799

800

78

    cairo_matrix_init_identity (&gstate->ctm);

801

78

    cairo_matrix_init_identity (&gstate->ctm_inverse);

802

78

    gstate->is_identity = _cairo_matrix_is_identity (&gstate->target->device_transform);

803

804

805

void

806

6

_cairo_gstate_user_to_device (cairo_gstate_t *gstate, double *x, double *y)

807

808

6

    cairo_matrix_transform_point (&gstate->ctm, x, y);

809

6

810

811

void

812

6

_cairo_gstate_user_to_device_distance (cairo_gstate_t *gstate,

813

				       double *dx, double *dy)

814

815

6

    cairo_matrix_transform_distance (&gstate->ctm, dx, dy);

816

6

817

818

void

819

6

_cairo_gstate_device_to_user (cairo_gstate_t *gstate, double *x, double *y)

820

821

6

    cairo_matrix_transform_point (&gstate->ctm_inverse, x, y);

822

6

823

824

void

825

6

_cairo_gstate_device_to_user_distance (cairo_gstate_t *gstate,

826

				       double *dx, double *dy)

827

828

6

    cairo_matrix_transform_distance (&gstate->ctm_inverse, dx, dy);

829

6

830

831

void

832

463893

_do_cairo_gstate_user_to_backend (cairo_gstate_t *gstate, double *x, double *y)

833

834

463893

    cairo_matrix_transform_point (&gstate->ctm, x, y);

835

463893

    cairo_matrix_transform_point (&gstate->target->device_transform, x, y);

836

463893

837

838

void

839

597297

_do_cairo_gstate_user_to_backend_distance (cairo_gstate_t *gstate, double *x, double *y)

840

841

597297

    cairo_matrix_transform_distance (&gstate->ctm, x, y);

842

597297

    cairo_matrix_transform_distance (&gstate->target->device_transform, x, y);

843

597297

844

845

void

846

5007

_do_cairo_gstate_backend_to_user (cairo_gstate_t *gstate, double *x, double *y)

847

848

5007

    cairo_matrix_transform_point (&gstate->target->device_transform_inverse, x, y);

849

5007

    cairo_matrix_transform_point (&gstate->ctm_inverse, x, y);

850

5007

851

852

void

853

_do_cairo_gstate_backend_to_user_distance (cairo_gstate_t *gstate, double *x, double *y)

854

855

    cairo_matrix_transform_distance (&gstate->target->device_transform_inverse, x, y);

856

    cairo_matrix_transform_distance (&gstate->ctm_inverse, x, y);

857

858

859

void

860

261

_cairo_gstate_backend_to_user_rectangle (cairo_gstate_t *gstate,

861

                                         double *x1, double *y1,

862

                                         double *x2, double *y2,

863

                                         cairo_bool_t *is_tight)

864

865

    cairo_matrix_t matrix_inverse;

866

867

522

    if (! _cairo_matrix_is_identity (&gstate->target->device_transform_inverse) ||

868

261

    ! _cairo_matrix_is_identity (&gstate->ctm_inverse))

869

870

80

	cairo_matrix_multiply (&matrix_inverse,

871

80

			       &gstate->target->device_transform_inverse,

872

80

			       &gstate->ctm_inverse);

873

80

	_cairo_matrix_transform_bounding_box (&matrix_inverse,

874

					      x1, y1, x2, y2, is_tight);

875

876

877

    else

878

879

181

	if (is_tight)

880

6

	    *is_tight = TRUE;

881

882

261

883

884

/* XXX: NYI

885

cairo_status_t

886

_cairo_gstate_stroke_to_path (cairo_gstate_t *gstate)

887

888

    cairo_status_t status;

889

890

    _cairo_pen_init (&gstate);

891

    return CAIRO_STATUS_SUCCESS;

892

893

*/

894

895

void

896

108

_cairo_gstate_path_extents (cairo_gstate_t     *gstate,

897

			    cairo_path_fixed_t *path,

898

			    double *x1, double *y1,

899

			    double *x2, double *y2)

900

901

    cairo_box_t box;

902

    double px1, py1, px2, py2;

903

904

108

    if (_cairo_path_fixed_extents (path, &box)) {

905

102

	px1 = _cairo_fixed_to_double (box.p1.x);

906

102

	py1 = _cairo_fixed_to_double (box.p1.y);

907

102

	px2 = _cairo_fixed_to_double (box.p2.x);

908

102

	py2 = _cairo_fixed_to_double (box.p2.y);

909

910

102

	_cairo_gstate_backend_to_user_rectangle (gstate,

911

						 &px1, &py1, &px2, &py2,

912

						 NULL);

913

    } else {

914

6

	px1 = 0.0;

915

6

	py1 = 0.0;

916

6

	px2 = 0.0;

917

6

	py2 = 0.0;

918

919

920

108

    if (x1)

921

108

	*x1 = px1;

922

108

    if (y1)

923

108

	*y1 = py1;

924

108

    if (x2)

925

108

	*x2 = px2;

926

108

    if (y2)

927

108

	*y2 = py2;

928

108

929

930

static void

931

840598

_cairo_gstate_copy_pattern (cairo_pattern_t *pattern,

932

			    const cairo_pattern_t *original)

933

934

    /* First check if the we can replace the original with a much simpler

935

     * pattern. For example, gradients that are uniform or just have a single

936

     * stop can sometimes be replaced with a solid.

937

*/

938

939

840598

    if (_cairo_pattern_is_clear (original)) {

940

931

        _cairo_pattern_init_solid ((cairo_solid_pattern_t *) pattern,

941

				   CAIRO_COLOR_TRANSPARENT);

942

931

	return;

943

944

945

839667

    if (original->type == CAIRO_PATTERN_TYPE_LINEAR ||

946

838731

	original->type == CAIRO_PATTERN_TYPE_RADIAL)

947

948

        cairo_color_t color;

949

1449

	if (_cairo_gradient_pattern_is_solid ((cairo_gradient_pattern_t *) original,

950

					      NULL,

951

					      &color))

952

953

54

	    _cairo_pattern_init_solid ((cairo_solid_pattern_t *) pattern,

954

				       &color);

955

54

	    return;

956

957

958

959

839613

    _cairo_pattern_init_static_copy (pattern, original);

960

961

962

static void

963

840598

_cairo_gstate_copy_transformed_pattern (cairo_gstate_t  *gstate,

964

					cairo_pattern_t *pattern,

965

					const cairo_pattern_t *original,

966

					const cairo_matrix_t  *ctm_inverse)

967

968

/*

969

     * What calculations below do can be described in pseudo-code (so using nonexistent fields) as (using column vectors):

970

     * pattern->matrix = surface->device_transform *

971

     * 			 pattern->matrix *

972

     * 			 ctm_inverse *

973

     * 			 gstate->target->device_transform_inverse

974

975

     * The inverse of which is:

976

     * pattern->matrix_inverse = gstate->target->device_transform *

977

     * 				 ctm *

978

     * 				 pattern->matrix_inverse *

979

     * 				 surface->device_transform_inverse

980

*/

981

982

840598

    _cairo_gstate_copy_pattern (pattern, original);

983

984

840598

    if (original->type == CAIRO_PATTERN_TYPE_SURFACE) {

985

	cairo_surface_pattern_t *surface_pattern;

986

	cairo_surface_t *surface;

987

988

318667

        surface_pattern = (cairo_surface_pattern_t *) original;

989

318667

        surface = surface_pattern->surface;

990

991

318667

	if (_cairo_surface_has_device_transform (surface))

992

339

	    _cairo_pattern_pretransform (pattern, &surface->device_transform);

993

994

995

840598

    if (! _cairo_matrix_is_identity (ctm_inverse))

996

240521

	_cairo_pattern_transform (pattern, ctm_inverse);

997

998

840598

    if (_cairo_surface_has_device_transform (gstate->target)) {

999

828

        _cairo_pattern_transform (pattern,

1000

828

                                  &gstate->target->device_transform_inverse);

1001

1002

840598

1003

1004

static void

1005

838759

_cairo_gstate_copy_transformed_source (cairo_gstate_t   *gstate,

1006

				       cairo_pattern_t  *pattern)

1007

1008

838759

    _cairo_gstate_copy_transformed_pattern (gstate, pattern,

1009

838759

					    gstate->source,

1010

838759

					    &gstate->source_ctm_inverse);

1011

838759

1012

1013

static void

1014

1839

_cairo_gstate_copy_transformed_mask (cairo_gstate_t   *gstate,

1015

				     cairo_pattern_t  *pattern,

1016

				     cairo_pattern_t  *mask)

1017

1018

1839

    _cairo_gstate_copy_transformed_pattern (gstate, pattern,

1019

					    mask,

1020

1839

					    &gstate->ctm_inverse);

1021

1839

1022

1023

static cairo_operator_t

1024

801189

_reduce_op (cairo_gstate_t *gstate)

1025

1026

    cairo_operator_t op;

1027

    const cairo_pattern_t *pattern;

1028

1029

801189

    op = gstate->op;

1030

801189

    if (op != CAIRO_OPERATOR_SOURCE)

1031

497187

	return op;

1032

1033

304002

    pattern = gstate->source;

1034

304002

    if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) {

1035

3660

	const cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) pattern;

1036

3660

	if (solid->color.alpha_short <= 0x00ff) {

1037

165

	    op = CAIRO_OPERATOR_CLEAR;

1038

3495

	} else if ((gstate->target->content & CAIRO_CONTENT_ALPHA) == 0) {

1039

162

	    if ((solid->color.red_short |

1040

162

		 solid->color.green_short |

1041

162

		 solid->color.blue_short) <= 0x00ff)

1042

1043

		op = CAIRO_OPERATOR_CLEAR;

1044

1045

1046

300342

    } else if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {

1047

300207

	const cairo_surface_pattern_t *surface = (cairo_surface_pattern_t *) pattern;

1048

300207

	if (surface->surface->is_clear &&

1049

	    surface->surface->content & CAIRO_CONTENT_ALPHA)

1050

1051

	    op = CAIRO_OPERATOR_CLEAR;

1052

1053

    } else {

1054

135

	const cairo_gradient_pattern_t *gradient = (cairo_gradient_pattern_t *) pattern;

1055

135

	if (gradient->n_stops == 0)

1056

	    op = CAIRO_OPERATOR_CLEAR;

1057

1058

1059

304002

    return op;

1060

1061

1062

static cairo_status_t

1063

911080

_cairo_gstate_get_pattern_status (const cairo_pattern_t *pattern)

1064

1065

911080

    if (unlikely (pattern->type == CAIRO_PATTERN_TYPE_MESH &&

1066

		  ((const cairo_mesh_pattern_t *) pattern)->current_patch))

1067

1068

	/* If current patch != NULL, the pattern is under construction

1069

	 * and cannot be used as a source */

1070

	return CAIRO_STATUS_INVALID_MESH_CONSTRUCTION;

1071

1072

1073

911080

    return pattern->status;

1074

1075

1076

cairo_status_t

1077

374260

_cairo_gstate_paint (cairo_gstate_t *gstate)

1078

1079

    cairo_pattern_union_t source_pattern;

1080

    const cairo_pattern_t *pattern;

1081

    cairo_status_t status;

1082

    cairo_operator_t op;

1083

1084

374260

    status = _cairo_gstate_get_pattern_status (gstate->source);

1085

374260

    if (unlikely (status))

1086

	return status;

1087

1088

374260

    if (gstate->op == CAIRO_OPERATOR_DEST)

1089

9

	return CAIRO_STATUS_SUCCESS;

1090

1091

374251

    if (_cairo_clip_is_all_clipped (gstate->clip))

1092

18

	return CAIRO_STATUS_SUCCESS;

1093

1094

374233

    op = _reduce_op (gstate);

1095

374233

    if (op == CAIRO_OPERATOR_CLEAR) {

1096

1980

	pattern = &_cairo_pattern_clear.base;

1097

    } else {

1098

372253

	_cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);

1099

372253

	pattern = &source_pattern.base;

1100

1101

1102

374233

    return _cairo_surface_paint (gstate->target,

1103

				 op, pattern,

1104

374233

				 gstate->clip);

1105

1106

1107

cairo_status_t

1108

34404

_cairo_gstate_mask (cairo_gstate_t  *gstate,

1109

		    cairo_pattern_t *mask)

1110

1111

    cairo_pattern_union_t source_pattern, mask_pattern;

1112

    const cairo_pattern_t *source;

1113

    cairo_operator_t op;

1114

    cairo_status_t status;

1115

1116

34404

    status = _cairo_gstate_get_pattern_status (mask);

1117

34404

    if (unlikely (status))

1118

	return status;

1119

1120

34404

    status = _cairo_gstate_get_pattern_status (gstate->source);

1121

34404

    if (unlikely (status))

1122

	return status;

1123

1124

34404

    if (gstate->op == CAIRO_OPERATOR_DEST)

1125

3

	return CAIRO_STATUS_SUCCESS;

1126

1127

34401

    if (_cairo_clip_is_all_clipped (gstate->clip))

1128

6

	return CAIRO_STATUS_SUCCESS;

1129

1130

34395

    assert (gstate->opacity == 1.0);

1131

1132

34395

    if (_cairo_pattern_is_opaque (mask, NULL))

1133

32415

	return _cairo_gstate_paint (gstate);

1134

1135

1980

    if (_cairo_pattern_is_clear (mask) &&

1136

189

	_cairo_operator_bounded_by_mask (gstate->op))

1137

1138

141

	return CAIRO_STATUS_SUCCESS;

1139

1140

1141

1839

    op = _reduce_op (gstate);

1142

1839

    if (op == CAIRO_OPERATOR_CLEAR) {

1143

12

	source = &_cairo_pattern_clear.base;

1144

    } else {

1145

1827

	_cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);

1146

1827

	source = &source_pattern.base;

1147

1148

1839

    _cairo_gstate_copy_transformed_mask (gstate, &mask_pattern.base, mask);

1149

1150

1839

    if (source->type == CAIRO_PATTERN_TYPE_SOLID && !source->is_foreground_marker &&

1151

1218

	mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&

1152

129

	_cairo_operator_bounded_by_source (op))

1153

63

1154

63

	const cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) source;

1155

	cairo_color_t combined;

1156

1157

63

	if (mask_pattern.base.has_component_alpha) {

1158

#define M(R, A, B, c) R.c = A.c * B.c

1159

	    M(combined, solid->color, mask_pattern.solid.color, red);

1160

	    M(combined, solid->color, mask_pattern.solid.color, green);

1161

	    M(combined, solid->color, mask_pattern.solid.color, blue);

1162

	    M(combined, solid->color, mask_pattern.solid.color, alpha);

1163

#undef M

1164

	} else {

1165

63

	    combined = solid->color;

1166

63

	    _cairo_color_multiply_alpha (&combined, mask_pattern.solid.color.alpha);

1167

1168

1169

63

	_cairo_pattern_init_solid (&source_pattern.solid, &combined);

1170

1171

63

	status = _cairo_surface_paint (gstate->target, op,

1172

				       &source_pattern.base,

1173

63

				       gstate->clip);

1174

1175

    else

1176

1177

1776

	status = _cairo_surface_mask (gstate->target, op,

1178

				      source,

1179

				      &mask_pattern.base,

1180

1776

				      gstate->clip);

1181

1182

1183

1839

    return status;

1184

1185

1186

cairo_status_t

1187

39730

_cairo_gstate_stroke (cairo_gstate_t *gstate, cairo_path_fixed_t *path)

1188

1189

    cairo_pattern_union_t source_pattern;

1190

    cairo_stroke_style_t style;

1191

    double dash[2];

1192

    cairo_status_t status;

1193

    cairo_matrix_t aggregate_transform;

1194

    cairo_matrix_t aggregate_transform_inverse;

1195

1196

39730

    status = _cairo_gstate_get_pattern_status (gstate->source);

1197

39730

    if (unlikely (status))

1198

	return status;

1199

1200

39730

    if (gstate->op == CAIRO_OPERATOR_DEST)

1201

	return CAIRO_STATUS_SUCCESS;

1202

1203

39730

    if (gstate->stroke_style.line_width <= 0.0 && !gstate->stroke_style.is_hairline)

1204

9

	return CAIRO_STATUS_SUCCESS;

1205

1206

39721

    if (_cairo_clip_is_all_clipped (gstate->clip))

1207

9

	return CAIRO_STATUS_SUCCESS;

1208

1209

39712

    assert (gstate->opacity == 1.0);

1210

1211

39712

    cairo_matrix_multiply (&aggregate_transform,

1212

39712

                           &gstate->ctm,

1213

39712

                           &gstate->target->device_transform);

1214

39712

    cairo_matrix_multiply (&aggregate_transform_inverse,

1215

39712

                           &gstate->target->device_transform_inverse,

1216

39712

                           &gstate->ctm_inverse);

1217

1218

39712

    memcpy (&style, &gstate->stroke_style, sizeof (gstate->stroke_style));

1219

39712

    if (_cairo_stroke_style_dash_can_approximate (&gstate->stroke_style, &aggregate_transform, gstate->tolerance)) {

1220

        style.dash = dash;

1221

        _cairo_stroke_style_dash_approximate (&gstate->stroke_style, &gstate->ctm, gstate->tolerance,

1222

					      &style.dash_offset,

1223

					      style.dash,

1224

					      &style.num_dashes);

1225

1226

1227

39712

    _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);

1228

1229

39712

    return _cairo_surface_stroke (gstate->target,

1230

				  gstate->op,

1231

				  &source_pattern.base,

1232

				  path,

1233

				  &style,

1234

				  &aggregate_transform,

1235

				  &aggregate_transform_inverse,

1236

				  gstate->tolerance,

1237

				  gstate->antialias,

1238

39712

				  gstate->clip);

1239

1240

1241

cairo_status_t

1242

15

_cairo_gstate_in_stroke (cairo_gstate_t	    *gstate,

1243

			 cairo_path_fixed_t *path,

1244

			 double		     x,

1245

			 double		     y,

1246

			 cairo_bool_t	    *inside_ret)

1247

1248

    cairo_status_t status;

1249

    cairo_rectangle_int_t extents;

1250

    cairo_box_t limit;

1251

    cairo_traps_t traps;

1252

1253

15

    if (gstate->stroke_style.line_width <= 0.0) {

1254

9

	*inside_ret = FALSE;

1255

9

	return CAIRO_STATUS_SUCCESS;

1256

1257

1258

6

    _cairo_gstate_user_to_backend (gstate, &x, &y);

1259

1260

    /* Before we perform the expensive stroke analysis,

1261

     * check whether the point is within the extents of the path.

1262

*/

1263

6

    _cairo_path_fixed_approximate_stroke_extents (path,

1264

6

						  &gstate->stroke_style,

1265

6

						  &gstate->ctm,

1266

6

						  gstate->target->is_vector,

1267

						  &extents);

1268

6

    if (x < extents.x || x > extents.x + extents.width ||

1269

3

	y < extents.y || y > extents.y + extents.height)

1270

1271

3

	*inside_ret = FALSE;

1272

3

	return CAIRO_STATUS_SUCCESS;

1273

1274

1275

3

    limit.p1.x = _cairo_fixed_from_double (x) - 1;

1276

3

    limit.p1.y = _cairo_fixed_from_double (y) - 1;

1277

3

    limit.p2.x = limit.p1.x + 2;

1278

3

    limit.p2.y = limit.p1.y + 2;

1279

1280

3

    _cairo_traps_init (&traps);

1281

3

    _cairo_traps_limit (&traps, &limit, 1);

1282

1283

3

    status = _cairo_path_fixed_stroke_polygon_to_traps (path,

1284

3

							&gstate->stroke_style,

1285

3

							&gstate->ctm,

1286

3

							&gstate->ctm_inverse,

1287

							gstate->tolerance,

1288

							&traps);

1289

3

    if (unlikely (status))

1290

	goto BAIL;

1291

1292

3

    *inside_ret = _cairo_traps_contain (&traps, x, y);

1293

1294

3

BAIL:

1295

3

    _cairo_traps_fini (&traps);

1296

1297

3

    return status;

1298

1299

1300

cairo_status_t

1301

393338

_cairo_gstate_fill (cairo_gstate_t *gstate, cairo_path_fixed_t *path)

1302

1303

    cairo_status_t status;

1304

1305

393338

    status = _cairo_gstate_get_pattern_status (gstate->source);

1306

393338

    if (unlikely (status))

1307

	return status;

1308

1309

393338

    if (gstate->op == CAIRO_OPERATOR_DEST)

1310

2901

	return CAIRO_STATUS_SUCCESS;

1311

1312

390437

    if (_cairo_clip_is_all_clipped (gstate->clip))

1313

12

	return CAIRO_STATUS_SUCCESS;

1314

1315

390425

    assert (gstate->opacity == 1.0);

1316

1317

390425

    if (_cairo_path_fixed_fill_is_empty (path)) {

1318

210

	if (_cairo_operator_bounded_by_mask (gstate->op))

1319

135

	    return CAIRO_STATUS_SUCCESS;

1320

1321

75

	status = _cairo_surface_paint (gstate->target,

1322

				       CAIRO_OPERATOR_CLEAR,

1323

				       &_cairo_pattern_clear.base,

1324

75

				       gstate->clip);

1325

    } else {

1326

	cairo_pattern_union_t source_pattern;

1327

	const cairo_pattern_t *pattern;

1328

	cairo_operator_t op;

1329

	cairo_rectangle_int_t extents;

1330

	cairo_box_t box;

1331

1332

390215

	op = _reduce_op (gstate);

1333

390215

	if (op == CAIRO_OPERATOR_CLEAR) {

1334

141

	    pattern = &_cairo_pattern_clear.base;

1335

	} else {

1336

390074

	    _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);

1337

390074

	    pattern = &source_pattern.base;

1338

1339

1340

	/* Toolkits often paint the entire background with a fill */

1341

779691

	if (_cairo_surface_get_extents (gstate->target, &extents) &&

1342

670187

	    _cairo_path_fixed_is_box (path, &box) &&

1343

287849

	    box.p1.x <= _cairo_fixed_from_int (extents.x) &&

1344

8561

	    box.p1.y <= _cairo_fixed_from_int (extents.y) &&

1345

1664

	    box.p2.x >= _cairo_fixed_from_int (extents.x + extents.width) &&

1346

241

	    box.p2.y >= _cairo_fixed_from_int (extents.y + extents.height))

1347

1348

52

	    status = _cairo_surface_paint (gstate->target, op, pattern,

1349

52

					   gstate->clip);

1350

1351

	else

1352

1353

390163

	    status = _cairo_surface_fill (gstate->target, op, pattern,

1354

					  path,

1355

					  gstate->fill_rule,

1356

					  gstate->tolerance,

1357

					  gstate->antialias,

1358

390163

					  gstate->clip);

1359

1360

1361

1362

390290

    return status;

1363

1364

1365

cairo_bool_t

1366

145

_cairo_gstate_in_fill (cairo_gstate_t	  *gstate,

1367

		       cairo_path_fixed_t *path,

1368

		       double		   x,

1369

		       double		   y)

1370

1371

145

    _cairo_gstate_user_to_backend (gstate, &x, &y);

1372

1373

145

    return _cairo_path_fixed_in_fill (path,

1374

				      gstate->fill_rule,

1375

				      gstate->tolerance,

1376

				      x, y);

1377

1378

1379

cairo_bool_t

1380

6

_cairo_gstate_in_clip (cairo_gstate_t	  *gstate,

1381

		       double		   x,

1382

		       double		   y)

1383

1384

6

    cairo_clip_t *clip = gstate->clip;

1385

    int i;

1386

1387

6

    if (_cairo_clip_is_all_clipped (clip))

1388

	return FALSE;

1389

1390

6

    if (clip == NULL)

1391

6

	return TRUE;

1392

1393

    _cairo_gstate_user_to_backend (gstate, &x, &y);

1394

1395

    if (x <  clip->extents.x ||

1396

	x >= clip->extents.x + clip->extents.width ||

1397

	y <  clip->extents.y ||

1398

	y >= clip->extents.y + clip->extents.height)

1399

1400

	return FALSE;

1401

1402

1403

    if (clip->num_boxes) {

1404

	int fx, fy;

1405

1406

	fx = _cairo_fixed_from_double (x);

1407

	fy = _cairo_fixed_from_double (y);

1408

	for (i = 0; i < clip->num_boxes; i++) {

1409

	    if (fx >= clip->boxes[i].p1.x && fx <= clip->boxes[i].p2.x &&

1410

		fy >= clip->boxes[i].p1.y && fy <= clip->boxes[i].p2.y)

1411

		break;

1412

1413

	if (i == clip->num_boxes)

1414

	    return FALSE;

1415

1416

1417

    if (clip->path) {

1418

	cairo_clip_path_t *clip_path = clip->path;

1419

	do {

1420

	    if (! _cairo_path_fixed_in_fill (&clip_path->path,

1421

					     clip_path->fill_rule,

1422

					     clip_path->tolerance,

1423

					     x, y))

1424

		return FALSE;

1425

	} while ((clip_path = clip_path->prev) != NULL);

1426

1427

1428

    return TRUE;

1429

1430

1431

cairo_status_t

1432

6

_cairo_gstate_copy_page (cairo_gstate_t *gstate)

1433

1434

6

    cairo_surface_copy_page (gstate->target);

1435

6

    return cairo_surface_status (gstate->target);

1436

1437

1438

cairo_status_t

1439

6

_cairo_gstate_show_page (cairo_gstate_t *gstate)

1440

1441

6

    cairo_surface_show_page (gstate->target);

1442

6

    return cairo_surface_status (gstate->target);

1443

1444

1445

static void

1446

120

_cairo_gstate_extents_to_user_rectangle (cairo_gstate_t	  *gstate,

1447

					 const cairo_box_t *extents,

1448

					 double *x1, double *y1,

1449

					 double *x2, double *y2)

1450

1451

    double px1, py1, px2, py2;

1452

1453

120

    px1 = _cairo_fixed_to_double (extents->p1.x);

1454

120

    py1 = _cairo_fixed_to_double (extents->p1.y);

1455

120

    px2 = _cairo_fixed_to_double (extents->p2.x);

1456

120

    py2 = _cairo_fixed_to_double (extents->p2.y);

1457

1458

120

    _cairo_gstate_backend_to_user_rectangle (gstate,

1459

					     &px1, &py1, &px2, &py2,

1460

					     NULL);

1461

120

    if (x1)

1462

120

	*x1 = px1;

1463

120

    if (y1)

1464

120

	*y1 = py1;

1465

120

    if (x2)

1466

120

	*x2 = px2;

1467

120

    if (y2)

1468

120

	*y2 = py2;

1469

120

1470

1471

cairo_status_t

1472

120

_cairo_gstate_stroke_extents (cairo_gstate_t	 *gstate,

1473

			      cairo_path_fixed_t *path,

1474

                              double *x1, double *y1,

1475

			      double *x2, double *y2)

1476

1477

    cairo_int_status_t status;

1478

    cairo_box_t extents;

1479

    cairo_bool_t empty;

1480

1481

120

    if (x1)

1482

120

	*x1 = 0.0;

1483

120

    if (y1)

1484

120

	*y1 = 0.0;

1485

120

    if (x2)

1486

120

	*x2 = 0.0;

1487

120

    if (y2)

1488

120

	*y2 = 0.0;

1489

1490

120

    if (gstate->stroke_style.line_width <= 0.0)

1491

9

	return CAIRO_STATUS_SUCCESS;

1492

1493

111

    status = CAIRO_INT_STATUS_UNSUPPORTED;

1494

111

    if (_cairo_path_fixed_stroke_is_rectilinear (path)) {

1495

	cairo_boxes_t boxes;

1496

1497

72

	_cairo_boxes_init (&boxes);

1498

72

	status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,

1499

72

								&gstate->stroke_style,

1500

72

								&gstate->ctm,

1501

								gstate->antialias,

1502

								&boxes);

1503

72

	empty = boxes.num_boxes == 0;

1504

72

	if (! empty)

1505

27

	    _cairo_boxes_extents (&boxes, &extents);

1506

72

	_cairo_boxes_fini (&boxes);

1507

1508

1509

111

    if (status == CAIRO_INT_STATUS_UNSUPPORTED) {

1510

	cairo_polygon_t polygon;

1511

1512

57

	_cairo_polygon_init (&polygon, NULL, 0);

1513

57

	status = _cairo_path_fixed_stroke_to_polygon (path,

1514

57

						      &gstate->stroke_style,

1515

57

						      &gstate->ctm,

1516

57

						      &gstate->ctm_inverse,

1517

						      gstate->tolerance,

1518

						      &polygon);

1519

57

	empty = polygon.num_edges == 0;

1520

57

	if (! empty)

1521

57

	    extents = polygon.extents;

1522

57

	_cairo_polygon_fini (&polygon);

1523

1524

111

    if (! empty) {

1525

84

	_cairo_gstate_extents_to_user_rectangle (gstate, &extents,

1526

						 x1, y1, x2, y2);

1527

1528

1529

111

    return status;

1530

1531

1532

cairo_status_t

1533

78

_cairo_gstate_fill_extents (cairo_gstate_t     *gstate,

1534

			    cairo_path_fixed_t *path,

1535

                            double *x1, double *y1,

1536

			    double *x2, double *y2)

1537

1538

    cairo_status_t status;

1539

    cairo_box_t extents;

1540

    cairo_bool_t empty;

1541

1542

78

    if (x1)

1543

78

	*x1 = 0.0;

1544

78

    if (y1)

1545

78

	*y1 = 0.0;

1546

78

    if (x2)

1547

78

	*x2 = 0.0;

1548

78

    if (y2)

1549

78

	*y2 = 0.0;

1550

1551

78

    if (_cairo_path_fixed_fill_is_empty (path))

1552

36

	return CAIRO_STATUS_SUCCESS;

1553

1554

42

    if (_cairo_path_fixed_fill_is_rectilinear (path)) {

1555

	cairo_boxes_t boxes;

1556

1557

36

	_cairo_boxes_init (&boxes);

1558

36

	status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,

1559

							      gstate->fill_rule,

1560

							      gstate->antialias,

1561

							      &boxes);

1562

36

	empty = boxes.num_boxes == 0;

1563

36

	if (! empty)

1564

30

	    _cairo_boxes_extents (&boxes, &extents);

1565

1566

36

	_cairo_boxes_fini (&boxes);

1567

    } else {

1568

	cairo_traps_t traps;

1569

1570

6

	_cairo_traps_init (&traps);

1571

1572

6

	status = _cairo_path_fixed_fill_to_traps (path,

1573

						  gstate->fill_rule,

1574

						  gstate->tolerance,

1575

						  &traps);

1576

6

	empty = traps.num_traps == 0;

1577

6

	if (! empty)

1578

6

	    _cairo_traps_extents (&traps, &extents);

1579

1580

6

	_cairo_traps_fini (&traps);

1581

1582

1583

42

    if (! empty) {

1584

36

	_cairo_gstate_extents_to_user_rectangle (gstate, &extents,

1585

						 x1, y1, x2, y2);

1586

1587

1588

42

    return status;

1589

1590

1591

cairo_status_t

1592

300435

_cairo_gstate_reset_clip (cairo_gstate_t *gstate)

1593

1594

300435

    _cairo_clip_destroy (gstate->clip);

1595

300435

    gstate->clip = NULL;

1596

1597

300435

    return CAIRO_STATUS_SUCCESS;

1598

1599

1600

cairo_status_t

1601

305463

_cairo_gstate_clip (cairo_gstate_t *gstate, cairo_path_fixed_t *path)

1602

1603

305463

    gstate->clip =

1604

305463

	_cairo_clip_intersect_path (gstate->clip,

1605

				    path,

1606

				    gstate->fill_rule,

1607

				    gstate->tolerance,

1608

				    gstate->antialias);

1609

    /* XXX */

1610

305463

    return CAIRO_STATUS_SUCCESS;

1611

1612

1613

static cairo_bool_t

1614

34961

_cairo_gstate_int_clip_extents (cairo_gstate_t        *gstate,

1615

				cairo_rectangle_int_t *extents)

1616

1617

    cairo_bool_t is_bounded;

1618

1619

34961

    is_bounded = _cairo_surface_get_extents (gstate->target, extents);

1620

1621

34961

    if (gstate->clip) {

1622

97

	_cairo_rectangle_intersect (extents,

1623

97

				    _cairo_clip_get_extents (gstate->clip));

1624

97

	is_bounded = TRUE;

1625

1626

1627

34961

    return is_bounded;

1628

1629

1630

cairo_bool_t

1631

32

_cairo_gstate_clip_extents (cairo_gstate_t *gstate,

1632

		            double         *x1,

1633

		            double         *y1,

1634

			    double         *x2,

1635

			    double         *y2)

1636

1637

    cairo_rectangle_int_t extents;

1638

    double px1, py1, px2, py2;

1639

1640

32

    if (! _cairo_gstate_int_clip_extents (gstate, &extents))

1641

	return FALSE;

1642

1643

32

    px1 = extents.x;

1644

32

    py1 = extents.y;

1645

32

    px2 = extents.x + (int) extents.width;

1646

32

    py2 = extents.y + (int) extents.height;

1647

1648

32

    _cairo_gstate_backend_to_user_rectangle (gstate,

1649

					     &px1, &py1, &px2, &py2,

1650

					     NULL);

1651

1652

32

    if (x1)

1653

32

	*x1 = px1;

1654

32

    if (y1)

1655

32

	*y1 = py1;

1656

32

    if (x2)

1657

32

	*x2 = px2;

1658

32

    if (y2)

1659

32

	*y2 = py2;

1660

1661

32

    return TRUE;

1662

1663

1664

cairo_rectangle_list_t*

1665

15

_cairo_gstate_copy_clip_rectangle_list (cairo_gstate_t *gstate)

1666

1667

    cairo_rectangle_int_t extents;

1668

    cairo_rectangle_list_t *list;

1669

    cairo_clip_t *clip;

1670

1671

15

    if (_cairo_surface_get_extents (gstate->target, &extents))

1672

15

	clip = _cairo_clip_copy_intersect_rectangle (gstate->clip, &extents);

1673

    else

1674

	clip = gstate->clip;

1675

1676

15

    list = _cairo_clip_copy_rectangle_list (clip, gstate);

1677

1678

15

    if (clip != gstate->clip)

1679

14

	_cairo_clip_destroy (clip);

1680

1681

15

    return list;

1682

1683

1684

cairo_status_t

1685

3

_cairo_gstate_tag_begin (cairo_gstate_t *gstate,

1686

			 const char *tag_name, const char *attributes)

1687

1688

3

    return _cairo_surface_tag (gstate->target,

1689

			       TRUE, /* begin */

1690

			       tag_name,

1691

			       attributes ? attributes : "");

1692

1693

1694

cairo_status_t

1695

3

_cairo_gstate_tag_end (cairo_gstate_t *gstate,

1696

		       const char *tag_name)

1697

1698

3

    return _cairo_surface_tag (gstate->target,

1699

			       FALSE, /* begin */

1700

			       tag_name,

1701

			       NULL); /* attributes */

1702

1703

1704

static void

1705

192926

_cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate)

1706

1707

192926

    if (gstate->scaled_font == NULL)

1708

125813

	return;

1709

1710

67113

    if (gstate->previous_scaled_font != NULL)

1711

66924

	cairo_scaled_font_destroy (gstate->previous_scaled_font);

1712

1713

67113

    gstate->previous_scaled_font = gstate->scaled_font;

1714

67113

    gstate->scaled_font = NULL;

1715

1716

1717

cairo_status_t

1718

2745

_cairo_gstate_set_font_size (cairo_gstate_t *gstate,

1719

			     double          size)

1720

1721

2745

    _cairo_gstate_unset_scaled_font (gstate);

1722

1723

2745

    cairo_matrix_init_scale (&gstate->font_matrix, size, size);

1724

1725

2745

    return CAIRO_STATUS_SUCCESS;

1726

1727

1728

cairo_status_t

1729

27258

_cairo_gstate_set_font_matrix (cairo_gstate_t	    *gstate,

1730

			       const cairo_matrix_t *matrix)

1731

1732

27258

    if (memcmp (matrix, &gstate->font_matrix, sizeof (cairo_matrix_t)) == 0)

1733

27054

	return CAIRO_STATUS_SUCCESS;

1734

1735

204

    _cairo_gstate_unset_scaled_font (gstate);

1736

1737

204

    gstate->font_matrix = *matrix;

1738

1739

204

    return CAIRO_STATUS_SUCCESS;

1740

1741

1742

void

1743

51

_cairo_gstate_get_font_matrix (cairo_gstate_t *gstate,

1744

			       cairo_matrix_t *matrix)

1745

1746

51

    *matrix = gstate->font_matrix;

1747

51

1748

1749

void

1750

30153

_cairo_gstate_set_font_options (cairo_gstate_t             *gstate,

1751

				const cairo_font_options_t *options)

1752

1753

30153

    if (_cairo_font_options_compare (options, &gstate->font_options))

1754

18

	return;

1755

1756

30135

    _cairo_gstate_unset_scaled_font (gstate);

1757

1758

30135

    _cairo_font_options_fini (&gstate->font_options);

1759

30135

    _cairo_font_options_init_copy (&gstate->font_options, options);

1760

1761

1762

void

1763

81

_cairo_gstate_get_font_options (cairo_gstate_t       *gstate,

1764

				cairo_font_options_t *options)

1765

1766

81

    _cairo_font_options_fini (options);

1767

81

    _cairo_font_options_init_copy (options, &gstate->font_options);

1768

81

1769

1770

cairo_status_t

1771

34

_cairo_gstate_get_font_face (cairo_gstate_t     *gstate,

1772

			     cairo_font_face_t **font_face)

1773

1774

    cairo_status_t status;

1775

1776

34

    status = _cairo_gstate_ensure_font_face (gstate);

1777

34

    if (unlikely (status))

1778

	return status;

1779

1780

34

    *font_face = gstate->font_face;

1781

1782

34

    return CAIRO_STATUS_SUCCESS;

1783

1784

1785

cairo_status_t

1786

67990

_cairo_gstate_get_scaled_font (cairo_gstate_t       *gstate,

1787

			       cairo_scaled_font_t **scaled_font)

1788

1789

    cairo_status_t status;

1790

1791

67990

    status = _cairo_gstate_ensure_scaled_font (gstate);

1792

67990

    if (unlikely (status))

1793

9

	return status;

1794

1795

67981

    *scaled_font = gstate->scaled_font;

1796

1797

67981

    return CAIRO_STATUS_SUCCESS;

1798

1799

1800

/*

1801

 * Like everything else in this file, fonts involve Too Many Coordinate Spaces;

1802

 * it is easy to get confused about what's going on.

1803

1804

 * The user's view

1805

 * ---------------

1806

1807

 * Users ask for things in user space. When cairo starts, a user space unit

1808

 * is about 1/96 inch, which is similar to (but importantly different from)

1809

 * the normal "point" units most users think in terms of. When a user

1810

 * selects a font, its scale is set to "one user unit". The user can then

1811

 * independently scale the user coordinate system *or* the font matrix, in

1812

 * order to adjust the rendered size of the font.

1813

1814

 * Metrics are returned in user space, whether they are obtained from

1815

 * the currently selected font in a  #cairo_t or from a #cairo_scaled_font_t

1816

 * which is a font specialized to a particular scale matrix, CTM, and target

1817

 * surface.

1818

1819

 * The font's view

1820

 * ---------------

1821

1822

 * Fonts are designed and stored (in say .ttf files) in "font space", which

1823

 * describes an "EM Square" (a design tile) and has some abstract number

1824

 * such as 1000, 1024, or 2048 units per "EM". This is basically an

1825

 * uninteresting space for us, but we need to remember that it exists.

1826

1827

 * Font resources (from libraries or operating systems) render themselves

1828

 * to a particular device. Since they do not want to make most programmers

1829

 * worry about the font design space, the scaling API is simplified to

1830

 * involve just telling the font the required pixel size of the EM square

1831

 * (that is, in device space).

1832

1833

1834

 * Cairo's gstate view

1835

 * -------------------

1836

1837

 * In addition to the CTM and CTM inverse, we keep a matrix in the gstate

1838

 * called the "font matrix" which describes the user's most recent

1839

 * font-scaling or font-transforming request. This is kept in terms of an

1840

 * abstract scale factor, composed with the CTM and used to set the font's

1841

 * pixel size. So if the user asks to "scale the font by 12", the matrix

1842

 * is:

1843

1844

 *   [ 12.0, 0.0, 0.0, 12.0, 0.0, 0.0 ]

1845

1846

 * It is an affine matrix, like all cairo matrices, where its tx and ty

1847

 * components are used to "nudging" fonts around and are handled in gstate

1848

 * and then ignored by the "scaled-font" layer.

1849

1850

 * In order to perform any action on a font, we must build an object

1851

 * called a #cairo_font_scale_t; this contains the central 2x2 matrix

1852

 * resulting from "font matrix * CTM" (sans the font matrix translation

1853

 * components as stated in the previous paragraph).

1854

1855

 * We pass this to the font when making requests of it, which causes it to

1856

 * reply for a particular [user request, device] combination, under the CTM

1857

 * (to accommodate the "zoom in" == "bigger fonts" issue above).

1858

1859

 * The other terms in our communication with the font are therefore in

1860

 * device space. When we ask it to perform text->glyph conversion, it will

1861

 * produce a glyph string in device space. Glyph vectors we pass to it for

1862

 * measuring or rendering should be in device space. The metrics which we

1863

 * get back from the font will be in device space. The contents of the

1864

 * global glyph image cache will be in device space.

1865

1866

1867

 * Cairo's public view

1868

 * -------------------

1869

1870

 * Since the values entering and leaving via public API calls are in user

1871

 * space, the gstate functions typically need to multiply arguments by the

1872

 * CTM (for user-input glyph vectors), and return values by the CTM inverse

1873

 * (for font responses such as metrics or glyph vectors).

1874

1875

*/

1876

1877

static cairo_status_t

1878

95108

_cairo_gstate_ensure_font_face (cairo_gstate_t *gstate)

1879

1880

    cairo_font_face_t *font_face;

1881

1882

95108

    if (gstate->font_face != NULL)

1883

95028

	return gstate->font_face->status;

1884

1885

1886

80

    font_face = cairo_toy_font_face_create (CAIRO_FONT_FAMILY_DEFAULT,

1887

					    CAIRO_FONT_SLANT_DEFAULT,

1888

					    CAIRO_FONT_WEIGHT_DEFAULT);

1889

80

    if (font_face->status)

1890

	return font_face->status;

1891

1892

80

    gstate->font_face = font_face;

1893

1894

80

    return CAIRO_STATUS_SUCCESS;

1895

1896

1897

static cairo_status_t

1898

282187

_cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate)

1899

1900

    cairo_status_t status;

1901

    cairo_font_options_t options;

1902

    cairo_scaled_font_t *scaled_font;

1903

    cairo_matrix_t font_ctm;

1904

1905

282187

    if (gstate->scaled_font != NULL)

1906

187113

	return gstate->scaled_font->status;

1907

1908

95074

    status = _cairo_gstate_ensure_font_face (gstate);

1909

95074

    if (unlikely (status))

1910

	return status;

1911

1912

95074

    cairo_surface_get_font_options (gstate->target, &options);

1913

95074

    cairo_font_options_merge (&options, &gstate->font_options);

1914

1915

95074

    cairo_matrix_multiply (&font_ctm,

1916

95074

			   &gstate->ctm,

1917

95074

			   &gstate->target->device_transform);

1918

1919

95074

    scaled_font = cairo_scaled_font_create (gstate->font_face,

1920

95074

				            &gstate->font_matrix,

1921

					    &font_ctm,

1922

					    &options);

1923

1924

95074

    _cairo_font_options_fini (&options);

1925

1926

95074

    status = cairo_scaled_font_status (scaled_font);

1927

95074

    if (unlikely (status))

1928

9

	return status;

1929

1930

95065

    gstate->scaled_font = scaled_font;

1931

1932

95065

    return CAIRO_STATUS_SUCCESS;

1933

1934

1935

cairo_status_t

1936

110793

_cairo_gstate_get_font_extents (cairo_gstate_t *gstate,

1937

				cairo_font_extents_t *extents)

1938

1939

110793

    cairo_status_t status = _cairo_gstate_ensure_scaled_font (gstate);

1940

110793

    if (unlikely (status))

1941

	return status;

1942

1943

110793

    cairo_scaled_font_extents (gstate->scaled_font, extents);

1944

1945

110793

    return cairo_scaled_font_status (gstate->scaled_font);

1946

1947

1948

cairo_status_t

1949

141077

_cairo_gstate_set_font_face (cairo_gstate_t    *gstate,

1950

			     cairo_font_face_t *font_face)

1951

1952

141077

    if (font_face && font_face->status)

1953

	return _cairo_error (font_face->status);

1954

1955

141077

    if (font_face == gstate->font_face)

1956

46263

	return CAIRO_STATUS_SUCCESS;

1957

1958

94814

    cairo_font_face_destroy (gstate->font_face);

1959

94814

    gstate->font_face = cairo_font_face_reference (font_face);

1960

1961

94814

    _cairo_gstate_unset_scaled_font (gstate);

1962

1963

94814

    return CAIRO_STATUS_SUCCESS;

1964

1965

1966

cairo_status_t

1967

68310

_cairo_gstate_glyph_extents (cairo_gstate_t *gstate,

1968

			     const cairo_glyph_t *glyphs,

1969

			     int num_glyphs,

1970

			     cairo_text_extents_t *extents)

1971

1972

    cairo_status_t status;

1973

1974

68310

    status = _cairo_gstate_ensure_scaled_font (gstate);

1975

68310

    if (unlikely (status))

1976

	return status;

1977

1978

68310

    cairo_scaled_font_glyph_extents (gstate->scaled_font,

1979

				     glyphs, num_glyphs,

1980

				     extents);

1981

1982

68310

    return cairo_scaled_font_status (gstate->scaled_font);

1983

1984

1985

cairo_status_t

1986

34944

_cairo_gstate_show_text_glyphs (cairo_gstate_t		   *gstate,

1987

				const cairo_glyph_t	   *glyphs,

1988

				int			    num_glyphs,

1989

				cairo_glyph_text_info_t    *info)

1990

1991

    cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];

1992

    cairo_text_cluster_t stack_transformed_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)];

1993

    cairo_pattern_union_t source_pattern;

1994

    cairo_glyph_t *transformed_glyphs;

1995

    const cairo_pattern_t *pattern;

1996

    cairo_text_cluster_t *transformed_clusters;

1997

    cairo_operator_t op;

1998

    cairo_status_t status;

1999

2000

34944

    status = _cairo_gstate_get_pattern_status (gstate->source);

2001

34944

    if (unlikely (status))

2002

	return status;

2003

2004

34944

    if (gstate->op == CAIRO_OPERATOR_DEST)

2005

3

	return CAIRO_STATUS_SUCCESS;

2006

2007

34941

    if (_cairo_clip_is_all_clipped (gstate->clip))

2008

12

	return CAIRO_STATUS_SUCCESS;

2009

2010

34929

    status = _cairo_gstate_ensure_scaled_font (gstate);

2011

34929

    if (unlikely (status))

2012

	return status;

2013

2014

34929

    transformed_glyphs = stack_transformed_glyphs;

2015

34929

    transformed_clusters = stack_transformed_clusters;

2016

2017

34929

    if (num_glyphs > ARRAY_LENGTH (stack_transformed_glyphs)) {

2018

18

	transformed_glyphs = cairo_glyph_allocate (num_glyphs);

2019

18

	if (unlikely (transformed_glyphs == NULL))

2020

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

2021

2022

2023

34929

    if (info != NULL) {

2024

216

	if (info->num_clusters > ARRAY_LENGTH (stack_transformed_clusters)) {

2025

	    transformed_clusters = cairo_text_cluster_allocate (info->num_clusters);

2026

	    if (unlikely (transformed_clusters == NULL)) {

2027

		status = _cairo_error (CAIRO_STATUS_NO_MEMORY);

2028

		goto CLEANUP_GLYPHS;

2029

2030

2031

2032

216

	_cairo_gstate_transform_glyphs_to_backend (gstate,

2033

						   glyphs, num_glyphs,

2034

						   info->clusters,

2035

						   info->num_clusters,

2036

						   info->cluster_flags,

2037

						   transformed_glyphs,

2038

						   &num_glyphs,

2039

						   transformed_clusters,

2040

						   TRUE);

2041

    } else {

2042

34713

	_cairo_gstate_transform_glyphs_to_backend (gstate,

2043

						   glyphs, num_glyphs,

2044

						   NULL, 0, 0,

2045

						   transformed_glyphs,

2046

						   &num_glyphs,

2047

						   NULL,

2048

						   TRUE);

2049

2050

2051

34929

    if (num_glyphs == 0)

2052

27

	goto CLEANUP_GLYPHS;

2053

2054

34902

    op = _reduce_op (gstate);

2055

34902

    if (op == CAIRO_OPERATOR_CLEAR) {

2056

9

	pattern = &_cairo_pattern_clear.base;

2057

    } else {

2058

34893

	_cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);

2059

34893

	pattern = &source_pattern.base;

2060

2061

2062

    /* For really huge font sizes, we can just do path;fill instead of

2063

     * show_glyphs, as show_glyphs would put excess pressure on the cache,

2064

     * and moreover, not all components below us correctly handle huge font

2065

     * sizes.  I wanted to set the limit at 256.  But alas, seems like cairo's

2066

     * rasterizer is something like ten times slower than freetype's for huge

2067

     * sizes.  So, no win just yet.  For now, do it for insanely-huge sizes,

2068

     * just to make sure we don't make anyone unhappy.  When we get a really

2069

     * fast rasterizer in cairo, we may want to readjust this.

2070

2071

     * Needless to say, do this only if show_text_glyphs is not available. */

2072

69501

    if (cairo_surface_has_show_text_glyphs (gstate->target) ||

2073

34599

	_cairo_scaled_font_get_max_scale (gstate->scaled_font) <= 10240)

2074

2075

2076

34902

	if (info != NULL) {

2077

210

	    status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,

2078

						      info->utf8, info->utf8_len,

2079

						      transformed_glyphs, num_glyphs,

2080

						      transformed_clusters, info->num_clusters,

2081

						      info->cluster_flags,

2082

						      gstate->scaled_font,

2083

210

						      gstate->clip);

2084

	} else {

2085

34692

	    status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,

2086

						      NULL, 0,

2087

						      transformed_glyphs, num_glyphs,

2088

						      NULL, 0, 0,

2089

						      gstate->scaled_font,

2090

34692

						      gstate->clip);

2091

2092

2093

    else

2094

2095

	cairo_path_fixed_t path;

2096

2097

	_cairo_path_fixed_init (&path);

2098

2099

	status = _cairo_scaled_font_glyph_path (gstate->scaled_font,

2100

						transformed_glyphs, num_glyphs,

2101

						&path);

2102

2103

	if (status == CAIRO_STATUS_SUCCESS) {

2104

	    status = _cairo_surface_fill (gstate->target, op, pattern,

2105

					  &path,

2106

					  CAIRO_FILL_RULE_WINDING,

2107

					  gstate->tolerance,

2108

					  gstate->scaled_font->options.antialias,

2109

					  gstate->clip);

2110

2111

2112

	_cairo_path_fixed_fini (&path);

2113

2114

2115

34929

CLEANUP_GLYPHS:

2116

34929

    if (transformed_glyphs != stack_transformed_glyphs)

2117

18

      cairo_glyph_free (transformed_glyphs);

2118

34929

    if (transformed_clusters != stack_transformed_clusters)

2119

      cairo_text_cluster_free (transformed_clusters);

2120

2121

34929

    return status;

2122

2123

2124

cairo_status_t

2125

165

_cairo_gstate_glyph_path (cairo_gstate_t      *gstate,

2126

			  const cairo_glyph_t *glyphs,

2127

			  int		       num_glyphs,

2128

			  cairo_path_fixed_t  *path)

2129

2130

    cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];

2131

    cairo_glyph_t *transformed_glyphs;

2132

    cairo_status_t status;

2133

2134

165

    status = _cairo_gstate_ensure_scaled_font (gstate);

2135

165

    if (unlikely (status))

2136

	return status;

2137

2138

165

    if (num_glyphs < ARRAY_LENGTH (stack_transformed_glyphs)) {

2139

165

	transformed_glyphs = stack_transformed_glyphs;

2140

    } else {

2141

	transformed_glyphs = cairo_glyph_allocate (num_glyphs);

2142

	if (unlikely (transformed_glyphs == NULL))

2143

	    return _cairo_error (CAIRO_STATUS_NO_MEMORY);

2144

2145

2146

165

    _cairo_gstate_transform_glyphs_to_backend (gstate,

2147

					       glyphs, num_glyphs,

2148

					       NULL, 0, 0,

2149

					       transformed_glyphs,

2150

					       &num_glyphs, NULL, FALSE);

2151

2152

165

    status = _cairo_scaled_font_glyph_path (gstate->scaled_font,

2153

					    transformed_glyphs, num_glyphs,

2154

					    path);

2155

2156

165

    if (transformed_glyphs != stack_transformed_glyphs)

2157

      cairo_glyph_free (transformed_glyphs);

2158

2159

165

    return status;

2160

2161

2162

cairo_status_t

2163

138

_cairo_gstate_set_antialias (cairo_gstate_t *gstate,

2164

			     cairo_antialias_t antialias)

2165

2166

138

    gstate->antialias = antialias;

2167

2168

138

    return CAIRO_STATUS_SUCCESS;

2169

2170

2171

cairo_antialias_t

2172

6

_cairo_gstate_get_antialias (cairo_gstate_t *gstate)

2173

2174

6

    return gstate->antialias;

2175

2176

2177

/**

2178

 * _cairo_gstate_transform_glyphs_to_backend:

2179

 * @gstate: a #cairo_gstate_t

2180

 * @glyphs: the array of #cairo_glyph_t objects to be transformed

2181

 * @num_glyphs: the number of elements in @glyphs

2182

 * @transformed_glyphs: a pre-allocated array of at least @num_glyphs

2183

 * #cairo_glyph_t objects

2184

 * @num_transformed_glyphs: the number of elements in @transformed_glyphs

2185

 * after dropping out of bounds glyphs, or %NULL if glyphs shouldn't be

2186

 * dropped

2187

2188

 * Transform an array of glyphs to backend space by first adding the offset

2189

 * of the font matrix, then transforming from user space to backend space.

2190

 * The result of the transformation is placed in @transformed_glyphs.

2191

2192

 * This also uses information from the scaled font and the surface to

2193

 * cull/drop glyphs that will not be visible.

2194

**/

2195

static void

2196

35094

_cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t	*gstate,

2197

                                           const cairo_glyph_t	*glyphs,

2198

                                           int			 num_glyphs,

2199

					   const cairo_text_cluster_t	*clusters,

2200

					   int			 num_clusters,

2201

					   cairo_text_cluster_flags_t cluster_flags,

2202

                                           cairo_glyph_t	*transformed_glyphs,

2203

					   int			*num_transformed_glyphs,

2204

					   cairo_text_cluster_t *transformed_clusters,

2205

					   cairo_bool_t         perform_early_clip)

2206

2207

    cairo_rectangle_int_t surface_extents;

2208

35094

    cairo_matrix_t *ctm = &gstate->ctm;

2209

35094

    cairo_matrix_t *font_matrix = &gstate->font_matrix;

2210

35094

    cairo_matrix_t *device_transform = &gstate->target->device_transform;

2211

35094

    cairo_bool_t drop = FALSE;

2212

35094

    double x1 = 0, x2 = 0, y1 = 0, y2 = 0;

2213

    int i, j, k;

2214

2215

35094

    drop = TRUE;

2216

35094

    if (!perform_early_clip || !_cairo_gstate_int_clip_extents (gstate, &surface_extents)) {

2217

468

	drop = FALSE; /* unbounded surface */

2218

    } else {

2219

34626

	double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font);

2220

34626

	if (surface_extents.width == 0 || surface_extents.height == 0) {

2221

	  /* No visible area.  Don't draw anything */

2222

27

	  *num_transformed_glyphs = 0;

2223

27

	  return;

2224

2225

	/* XXX We currently drop any glyphs that have their position outside

2226

	 * of the surface boundaries by a safety margin depending on the

2227

	 * font scale.  This however can fail in extreme cases where the

2228

	 * font has really long swashes for example...  We can correctly

2229

	 * handle that by looking the glyph up and using its device bbox

2230

	 * to device if it's going to be visible, but I'm not inclined to

2231

	 * do that now.

2232

*/

2233

34599

	x1 = surface_extents.x - scale10;

2234

34599

	y1 = surface_extents.y - scale10;

2235

34599

	x2 = surface_extents.x + (int) surface_extents.width  + scale10;

2236

34599

	y2 = surface_extents.y + (int) surface_extents.height + scale10;

2237

2238

2239

35067

    if (!drop)

2240

468

	*num_transformed_glyphs = num_glyphs;

2241

2242

#define KEEP_GLYPH(glyph) (x1 <= glyph.x && glyph.x <= x2 && y1 <= glyph.y && glyph.y <= y2)

2243

2244

35067

    j = 0;

2245

69627

    if (_cairo_matrix_is_identity (ctm) &&

2246

34560

        _cairo_matrix_is_identity (device_transform) &&

2247

34560

	font_matrix->x0 == 0 && font_matrix->y0 == 0)

2248

2249

34548

	if (! drop) {

2250

213

	    memcpy (transformed_glyphs, glyphs,

2251

		    num_glyphs * sizeof (cairo_glyph_t));

2252

213

	    memcpy (transformed_clusters, clusters,

2253

		    num_clusters * sizeof (cairo_text_cluster_t));

2254

213

	    j = num_glyphs;

2255

34335

	} else if (num_clusters == 0) {

2256

791763

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

2257

757428

		transformed_glyphs[j].index = glyphs[i].index;

2258

757428

		transformed_glyphs[j].x = glyphs[i].x;

2259

757428

		transformed_glyphs[j].y = glyphs[i].y;

2260

757428

		if (KEEP_GLYPH (transformed_glyphs[j]))

2261

756468

		    j++;

2262

2263

	} else {

2264

	    const cairo_glyph_t *cur_glyph;

2265

2266

	    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2267

		cur_glyph = glyphs + num_glyphs - 1;

2268

	    else

2269

		cur_glyph = glyphs;

2270

2271

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

2272

		cairo_bool_t cluster_visible = FALSE;

2273

2274

		for (k = 0; k < clusters[i].num_glyphs; k++) {

2275

		    transformed_glyphs[j+k].index = cur_glyph->index;

2276

		    transformed_glyphs[j+k].x = cur_glyph->x;

2277

		    transformed_glyphs[j+k].y = cur_glyph->y;

2278

		    if (KEEP_GLYPH (transformed_glyphs[j+k]))

2279

			cluster_visible = TRUE;

2280

2281

		    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2282

			cur_glyph--;

2283

		    else

2284

			cur_glyph++;

2285

2286

2287

		transformed_clusters[i] = clusters[i];

2288

		if (cluster_visible)

2289

		    j += k;

2290

		else

2291

		    transformed_clusters[i].num_glyphs = 0;

2292

2293

2294

2295

702

    else if (_cairo_matrix_is_translation (ctm) &&

2296

183

             _cairo_matrix_is_translation (device_transform))

2297

183

2298

183

        double tx = font_matrix->x0 + ctm->x0 + device_transform->x0;

2299

183

        double ty = font_matrix->y0 + ctm->y0 + device_transform->y0;

2300

2301

183

	if (! drop || num_clusters == 0) {

2302

11931

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

2303

11748

		transformed_glyphs[j].index = glyphs[i].index;

2304

11748

		transformed_glyphs[j].x = glyphs[i].x + tx;

2305

11748

		transformed_glyphs[j].y = glyphs[i].y + ty;

2306

11748

		if (!drop || KEEP_GLYPH (transformed_glyphs[j]))

2307

11748

		    j++;

2308

2309

183

	    memcpy (transformed_clusters, clusters,

2310

		    num_clusters * sizeof (cairo_text_cluster_t));

2311

	} else {

2312

	    const cairo_glyph_t *cur_glyph;

2313

2314

	    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2315

		cur_glyph = glyphs + num_glyphs - 1;

2316

	    else

2317

		cur_glyph = glyphs;

2318

2319

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

2320

		cairo_bool_t cluster_visible = FALSE;

2321

2322

		for (k = 0; k < clusters[i].num_glyphs; k++) {

2323

		    transformed_glyphs[j+k].index = cur_glyph->index;

2324

		    transformed_glyphs[j+k].x = cur_glyph->x + tx;

2325

		    transformed_glyphs[j+k].y = cur_glyph->y + ty;

2326

		    if (KEEP_GLYPH (transformed_glyphs[j+k]))

2327

			cluster_visible = TRUE;

2328

2329

		    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2330

			cur_glyph--;

2331

		    else

2332

			cur_glyph++;

2333

2334

2335

		transformed_clusters[i] = clusters[i];

2336

		if (cluster_visible)

2337

		    j += k;

2338

		else

2339

		    transformed_clusters[i].num_glyphs = 0;

2340

2341

2342

2343

    else

2344

2345

        cairo_matrix_t aggregate_transform;

2346

2347

336

        cairo_matrix_init_translate (&aggregate_transform,

2348

                                     gstate->font_matrix.x0,

2349

                                     gstate->font_matrix.y0);

2350

336

        cairo_matrix_multiply (&aggregate_transform,

2351

                               &aggregate_transform, ctm);

2352

336

        cairo_matrix_multiply (&aggregate_transform,

2353

                               &aggregate_transform, device_transform);

2354

2355

336

	if (! drop || num_clusters == 0) {

2356

1119

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

2357

783

		transformed_glyphs[j] = glyphs[i];

2358

783

		cairo_matrix_transform_point (&aggregate_transform,

2359

783

					      &transformed_glyphs[j].x,

2360

783

					      &transformed_glyphs[j].y);

2361

783

		if (! drop || KEEP_GLYPH (transformed_glyphs[j]))

2362

783

		    j++;

2363

2364

336

	    memcpy (transformed_clusters, clusters,

2365

		    num_clusters * sizeof (cairo_text_cluster_t));

2366

	} else {

2367

	    const cairo_glyph_t *cur_glyph;

2368

2369

	    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2370

		cur_glyph = glyphs + num_glyphs - 1;

2371

	    else

2372

		cur_glyph = glyphs;

2373

2374

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

2375

		cairo_bool_t cluster_visible = FALSE;

2376

		for (k = 0; k < clusters[i].num_glyphs; k++) {

2377

		    transformed_glyphs[j+k] = *cur_glyph;

2378

		    cairo_matrix_transform_point (&aggregate_transform,

2379

						  &transformed_glyphs[j+k].x,

2380

						  &transformed_glyphs[j+k].y);

2381

		    if (KEEP_GLYPH (transformed_glyphs[j+k]))

2382

			cluster_visible = TRUE;

2383

2384

		    if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)

2385

			cur_glyph--;

2386

		    else

2387

			cur_glyph++;

2388

2389

2390

		transformed_clusters[i] = clusters[i];

2391

		if (cluster_visible)

2392

		    j += k;

2393

		else

2394

		    transformed_clusters[i].num_glyphs = 0;

2395

2396

2397

2398

35067

    *num_transformed_glyphs = j;

2399

2400

35067

    if (num_clusters != 0 && cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD) {

2401

	for (i = 0; i < --j; i++) {

2402

	    cairo_glyph_t tmp;

2403

2404

	    tmp = transformed_glyphs[i];

2405

	    transformed_glyphs[i] = transformed_glyphs[j];

2406

	    transformed_glyphs[j] = tmp;

2407

2408

2409