-
-
Notifications
You must be signed in to change notification settings - Fork 676
/
draw.py
785 lines (684 loc) · 30.2 KB
/
draw.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
# coding: utf8
"""
weasyprint.draw
---------------
Take an "after layout" box tree and draw it onto a cairo context.
:copyright: Copyright 2011-2012 Simon Sapin and contributors, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
from __future__ import division, unicode_literals
import contextlib
import math
import operator
import cairo
from .formatting_structure import boxes
from .stacking import StackingContext
from .text import show_first_line
from .compat import xrange
# Map values of the image-rendering property to cairo FILTER values:
# Values are normalized to lower case.
IMAGE_RENDERING_TO_FILTER = dict(
optimizespeed=cairo.FILTER_FAST,
auto=cairo.FILTER_GOOD,
optimizequality=cairo.FILTER_BEST,
)
@contextlib.contextmanager
def stacked(context):
"""Save and restore the context when used with the ``with`` keyword."""
context.save()
try:
yield
finally:
context.restore()
def lighten(color, offset):
"""Return a lighter color (or darker, for negative offsets)."""
return (
color.red + offset,
color.green + offset,
color.blue + offset,
color.alpha)
def draw_page(page, context, enable_hinting):
"""Draw the given PageBox."""
stacking_context = StackingContext.from_page(page)
draw_box_background(
context, stacking_context.page, stacking_context.box, enable_hinting)
draw_canvas_background(context, page, enable_hinting)
draw_border(context, page, enable_hinting)
draw_stacking_context(context, stacking_context, enable_hinting)
def draw_box_background_and_border(context, page, box, enable_hinting):
draw_box_background(context, page, box, enable_hinting)
if not isinstance(box, boxes.TableBox):
draw_border(context, box, enable_hinting)
else:
for column_group in box.column_groups:
draw_box_background(context, page, column_group, enable_hinting)
for column in column_group.children:
draw_box_background(context, page, column, enable_hinting)
for row_group in box.children:
draw_box_background(context, page, row_group, enable_hinting)
for row in row_group.children:
draw_box_background(context, page, row, enable_hinting)
for cell in row.children:
draw_box_background(context, page, cell, enable_hinting)
if box.style.border_collapse == 'separate':
draw_border(context, box, enable_hinting)
for row_group in box.children:
for row in row_group.children:
for cell in row.children:
draw_border(context, cell, enable_hinting)
else:
draw_collapsed_borders(context, box, enable_hinting)
def draw_stacking_context(context, stacking_context, enable_hinting):
"""Draw a ``stacking_context`` on ``context``."""
# See http://www.w3.org/TR/CSS2/zindex.html
with stacked(context):
box = stacking_context.box
if box.is_absolutely_positioned() and box.style.clip:
top, right, bottom, left = box.style.clip
if top == 'auto':
top = 0
if right == 'auto':
right = 0
if bottom == 'auto':
bottom = box.border_height()
if left == 'auto':
left = box.border_width()
context.rectangle(
box.border_box_x() + right,
box.border_box_y() + top,
left - right,
bottom - top)
context.clip()
if box.style.overflow != 'visible':
context.rectangle(*box_rectangle(box, 'padding-box'))
context.clip()
if box.style.opacity < 1:
context.push_group()
apply_2d_transforms(context, box)
# Point 1 is done in draw_page
# Point 2
if isinstance(box, (boxes.BlockBox, boxes.MarginBox,
boxes.InlineBlockBox)):
# The canvas background was removed by set_canvas_background
draw_box_background_and_border(
context, stacking_context.page, box, enable_hinting)
# Point 3
for child_context in stacking_context.negative_z_contexts:
draw_stacking_context(context, child_context, enable_hinting)
# Point 4
for block in stacking_context.block_level_boxes:
draw_box_background_and_border(
context, stacking_context.page, block, enable_hinting)
# Point 5
for child_context in stacking_context.float_contexts:
draw_stacking_context(context, child_context, enable_hinting)
# Point 6
if isinstance(box, boxes.InlineBox):
draw_inline_level(
context, stacking_context.page, box, enable_hinting)
# Point 7
for block in [box] + stacking_context.blocks_and_cells:
marker_box = getattr(block, 'outside_list_marker', None)
if marker_box:
draw_inline_level(
context, stacking_context.page, marker_box, enable_hinting)
if isinstance(block, boxes.ReplacedBox):
draw_replacedbox(context, block)
else:
for child in block.children:
if isinstance(child, boxes.LineBox):
# TODO: draw inline tables
draw_inline_level(
context, stacking_context.page, child,
enable_hinting)
# Point 8
for child_context in stacking_context.zero_z_contexts:
draw_stacking_context(context, child_context, enable_hinting)
# Point 9
for child_context in stacking_context.positive_z_contexts:
draw_stacking_context(context, child_context, enable_hinting)
# Point 10
draw_outlines(context, box, enable_hinting)
if box.style.opacity < 1:
context.pop_group_to_source()
context.paint_with_alpha(box.style.opacity)
def box_rectangle(box, which_rectangle):
if which_rectangle == 'border-box':
return (
box.border_box_x(),
box.border_box_y(),
box.border_width(),
box.border_height(),
)
elif which_rectangle == 'padding-box':
return (
box.padding_box_x(),
box.padding_box_y(),
box.padding_width(),
box.padding_height(),
)
else:
assert which_rectangle == 'content-box', which_rectangle
return (
box.content_box_x(),
box.content_box_y(),
box.width,
box.height,
)
def background_positioning_area(page, box, style):
if style.background_attachment == 'fixed' and box is not page:
# Initial containing block
return box_rectangle(page, 'content-box')
else:
return box_rectangle(box, box.style.background_origin)
def draw_canvas_background(context, page, enable_hinting):
if not page.children or isinstance(page.children[0], boxes.MarginBox):
# Skip the canvas background on content-empty pages
# TODO: remove this when content empty pages still get boxes
# up to the break point, so that the backgrounds and borders are drawn.
return
root_box = page.children[0]
style = root_box.canvas_background
draw_background(context, style,
painting_area=box_rectangle(page, 'padding-box'),
positioning_area=background_positioning_area(page, root_box, style),
enable_hinting=enable_hinting)
def draw_box_background(context, page, box, enable_hinting):
"""Draw the box background color and image to a ``cairo.Context``."""
if box.style.visibility == 'hidden':
return
if box is page:
painting_area = None
else:
painting_area = box_rectangle(box, box.style.background_clip)
draw_background(
context, box.style, painting_area,
positioning_area=background_positioning_area(page, box, box.style),
enable_hinting=enable_hinting)
def percentage(value, refer_to):
"""Return the evaluated percentage value, or the value unchanged."""
if value.unit == 'px':
return value.value
else:
assert value.unit == '%'
return refer_to * value.value / 100
def draw_background(context, style, painting_area, positioning_area,
enable_hinting):
"""Draw the background color and image to a ``cairo.Context``."""
bg_color = style.background_color
image = style._fetched_background_image
if bg_color.alpha == 0 and image is None:
# No background.
return
with stacked(context):
if enable_hinting:
# Prefer crisp edges on background rectangles.
context.set_antialias(cairo.ANTIALIAS_NONE)
if painting_area:
context.rectangle(*painting_area)
context.clip()
#else: unrestricted, whole page box
# Background color
if bg_color.alpha > 0:
context.set_source_rgba(*bg_color)
context.paint()
# Background image
if image is None:
return
(positioning_x, positioning_y,
positioning_width, positioning_height) = positioning_area
context.translate(positioning_x, positioning_y)
pattern, intrinsic_width, intrinsic_height = image
bg_size = style.background_size
if bg_size in ('cover', 'contain'):
scale_x = scale_y = {'cover': max, 'contain': min}[bg_size](
positioning_width / intrinsic_width,
positioning_height / intrinsic_height)
image_width = intrinsic_width * scale_x
image_height = intrinsic_height * scale_y
elif bg_size == ('auto', 'auto'):
scale_x = scale_y = 1
image_width = intrinsic_width
image_height = intrinsic_height
elif bg_size[0] == 'auto':
image_height = percentage(bg_size[1], positioning_height)
scale_x = scale_y = image_height / intrinsic_height
image_width = intrinsic_width * scale_x
elif bg_size[1] == 'auto':
image_width = percentage(bg_size[0], positioning_width)
scale_x = scale_y = image_width / intrinsic_width
image_height = intrinsic_height * scale_y
else:
image_width = percentage(bg_size[0], positioning_width)
image_height = percentage(bg_size[1], positioning_height)
scale_x = image_width / intrinsic_width
scale_y = image_height / intrinsic_height
bg_position_x, bg_position_y = style.background_position
context.translate(
percentage(bg_position_x, positioning_width - image_width),
percentage(bg_position_y, positioning_height - image_height),
)
bg_repeat = style.background_repeat
if bg_repeat in ('repeat-x', 'repeat-y'):
# Get the current clip rectangle. This is the same as
# painting_area, but in new coordinates after translate()
clip_x1, clip_y1, clip_x2, clip_y2 = context.clip_extents()
clip_width = clip_x2 - clip_x1
clip_height = clip_y2 - clip_y1
if bg_repeat == 'repeat-x':
# Limit the drawn area vertically
clip_y1 = 0 # because of the last context.translate()
clip_height = image_height
else:
# repeat-y
# Limit the drawn area horizontally
clip_x1 = 0 # because of the last context.translate()
clip_width = image_width
# Second clip for the background image
context.rectangle(clip_x1, clip_y1, clip_width, clip_height)
context.clip()
if bg_repeat == 'no-repeat':
# The same image/pattern may have been used
# in a repeating background.
pattern.set_extend(cairo.EXTEND_NONE)
else:
pattern.set_extend(cairo.EXTEND_REPEAT)
# TODO: de-duplicate this with draw_replacedbox()
pattern.set_filter(IMAGE_RENDERING_TO_FILTER[style.image_rendering])
context.scale(scale_x, scale_y)
context.set_source(pattern)
context.paint()
def get_rectangle_edges(x, y, width, height):
"""Return the 4 edges of a rectangle as a list.
Edges are in clock-wise order, starting from the top.
Each edge is returned as ``(start_point, end_point)`` and each point
as ``(x, y)`` coordinates.
"""
# In clock-wise order, starting on top left
corners = [
(x, y),
(x + width, y),
(x + width, y + height),
(x, y + height)]
# clock-wise order, starting on top right
shifted_corners = corners[1:] + corners[:1]
return zip(corners, shifted_corners)
def xy_offset(x, y, offset_x, offset_y, offset):
"""Increment X and Y coordinates by the given offsets."""
return x + offset_x * offset, y + offset_y * offset
def draw_border(context, box, enable_hinting):
"""Draw the box border to a ``cairo.Context``."""
if box.style.visibility == 'hidden':
return
if all(getattr(box, 'border_%s_width' % side) == 0
for side in ['top', 'right', 'bottom', 'left']):
# No border, return early.
return
for side, border_edge, padding_edge in zip(
['top', 'right', 'bottom', 'left'],
get_rectangle_edges(
box.border_box_x(), box.border_box_y(),
box.border_width(), box.border_height(),
),
get_rectangle_edges(
box.padding_box_x(), box.padding_box_y(),
box.padding_width(), box.padding_height(),
),
):
width = getattr(box, 'border_%s_width' % side)
if width == 0:
continue
color = box.style['border_%s_color' % side]
if color.alpha == 0:
continue
style = box.style['border_%s_style' % side]
draw_border_segment(context, enable_hinting, style, width, color,
side, border_edge, padding_edge)
def draw_border_segment(context, enable_hinting, style, width, color, side,
border_edge, padding_edge):
with stacked(context):
context.set_source_rgba(*color)
x_offset, y_offset = {
'top': (0, 1), 'bottom': (0, -1), 'left': (1, 0), 'right': (-1, 0),
}[side]
if enable_hinting and (
# Borders smaller than 1 device unit would disappear
# without anti-aliasing.
math.hypot(*context.user_to_device(width, 0)) >= 1 and
math.hypot(*context.user_to_device(0, width)) >= 1):
# Avoid an artefact in the corner joining two solid borders
# of the same color.
context.set_antialias(cairo.ANTIALIAS_NONE)
if style not in ('dotted', 'dashed'):
# Clip on the trapezoid shape
"""
Clip on the trapezoid formed by the border edge (longer)
and the padding edge (shorter).
This is on the top side:
+---------------+ <= border edge ^
\ / |
\ / | top border width
\ / |
+-------+ <= padding edge v
<--> <--> <= left and right border widths
"""
border_start, border_stop = border_edge
padding_start, padding_stop = padding_edge
context.move_to(*border_start)
for point in [border_stop, padding_stop,
padding_start, border_start]:
context.line_to(*point)
context.clip()
if style == 'solid':
# Fill the whole trapezoid
context.paint()
elif style in ('inset', 'outset'):
do_lighten = (side in ('top', 'left')) ^ (style == 'inset')
factor = 1 if do_lighten else -1
context.set_source_rgba(*lighten(color, 0.5 * factor))
context.paint()
elif style in ('groove', 'ridge'):
# TODO: these would look better with more color stops
"""
Divide the width in 2 and stroke lines in different colors
+-------------+
1\ /2
1'\ / 2'
+-------+
"""
do_lighten = (side in ('top', 'left')) ^ (style == 'groove')
factor = 1 if do_lighten else -1
context.set_line_width(width / 2)
(x1, y1), (x2, y2) = border_edge
# from the border edge to the center of the first line
x1, y1 = xy_offset(x1, y1, x_offset, y_offset, width / 4)
x2, y2 = xy_offset(x2, y2, x_offset, y_offset, width / 4)
context.move_to(x1, y1)
context.line_to(x2, y2)
context.set_source_rgba(*lighten(color, 0.5 * factor))
context.stroke()
# Between the centers of both lines. 1/4 + 1/4 = 1/2
x1, y1 = xy_offset(x1, y1, x_offset, y_offset, width / 2)
x2, y2 = xy_offset(x2, y2, x_offset, y_offset, width / 2)
context.move_to(x1, y1)
context.line_to(x2, y2)
context.set_source_rgba(*lighten(color, -0.5 * factor))
context.stroke()
elif style == 'double':
"""
Divide the width in 3 and stroke both outer lines
+---------------+
1\ /2
\ /
1' \ / 2'
+-------+
"""
context.set_line_width(width / 3)
(x1, y1), (x2, y2) = border_edge
# from the border edge to the center of the first line
x1, y1 = xy_offset(x1, y1, x_offset, y_offset, width / 6)
x2, y2 = xy_offset(x2, y2, x_offset, y_offset, width / 6)
context.move_to(x1, y1)
context.line_to(x2, y2)
context.stroke()
# Between the centers of both lines. 1/6 + 1/3 + 1/6 = 2/3
x1, y1 = xy_offset(x1, y1, x_offset, y_offset, 2 * width / 3)
x2, y2 = xy_offset(x2, y2, x_offset, y_offset, 2 * width / 3)
context.move_to(x1, y1)
context.line_to(x2, y2)
context.stroke()
else:
assert style in ('dotted', 'dashed')
(x1, y1), (x2, y2) = border_edge
if style == 'dotted':
# Half-way from the extremities of the border and padding
# edges.
(px1, py1), (px2, py2) = padding_edge
x1 = (x1 + px1) / 2
x2 = (x2 + px2) / 2
y1 = (y1 + py1) / 2
y2 = (y2 + py2) / 2
"""
+---------------+
\ /
1 2
\ /
+-------+
"""
else: # dashed
# From the border edge to the middle:
x1, y1 = xy_offset(x1, y1, x_offset, y_offset, width / 2)
x2, y2 = xy_offset(x2, y2, x_offset, y_offset, width / 2)
"""
+---------------+
\ /
1 \ / 2
\ /
+-------+
"""
length = ((x2 - x1)**2 + (y2 - y1)**2) ** 0.5
dash = 2 * width
if style == 'dotted':
if context.user_to_device_distance(width, 0)[0] > 3:
# Round so that dash is a divisor of length,
# but not in the dots are too small.
dash = length / round(length / dash)
context.set_line_cap(cairo.LINE_CAP_ROUND)
context.set_dash([0, dash])
else: # dashed
# Round so that 2*dash is a divisor of length
dash = length / (2 * round(length / (2 * dash)))
context.set_dash([dash])
# Stroke along the line in === above, as wide as the border
context.move_to(x1, y1)
context.line_to(x2, y2)
context.set_line_width(width)
context.stroke()
def draw_outlines(context, box, enable_hinting):
width = box.style.outline_width
color = box.style.outline_color
style = box.style.outline_style
if box.style.visibility != 'hidden' and width != 0 and color.alpha != 0:
border_box = (box.border_box_x(), box.border_box_y(),
box.border_width(), box.border_height())
outline_box = (border_box[0] - width, border_box[1] - width,
border_box[2] + 2 * width,border_box[3] + 2 * width)
for side, border_edge, padding_edge in zip(
['top', 'right', 'bottom', 'left'],
get_rectangle_edges(*outline_box),
get_rectangle_edges(*border_box),
):
draw_border_segment(context, enable_hinting, style, width, color,
side, border_edge, padding_edge)
if isinstance(box, boxes.ParentBox):
for child in box.children:
if isinstance(child, boxes.Box):
draw_outlines(context, child, enable_hinting)
def draw_collapsed_borders(context, table, enable_hinting):
row_heights = [row.height for row_group in table.children
for row in row_group.children]
column_widths = table.column_widths
if not (row_heights and column_widths):
# One of the list is empty: don’t bother with empty tables
return
row_positions = [row.position_y for row_group in table.children
for row in row_group.children]
column_positions = table.column_positions
grid_height = len(row_heights)
grid_width = len(column_widths)
assert grid_width == len(column_positions)
# Add the end of the last column, but make a copy from the table attr.
column_positions += [column_positions[-1] + column_widths[-1]]
# Add the end of the last row. No copy here, we own this list
row_positions.append(row_positions[-1] + row_heights[-1])
vertical_borders, horizontal_borders = table.collapsed_border_grid
skipped_rows = table.skipped_rows
segments = []
def half_max_width(border_list, yx_pairs, vertical=True):
result = 0
for y, x in yx_pairs:
if (
(0 <= y < grid_height and 0 <= x <= grid_width)
if vertical else
(0 <= y <= grid_height and 0 <= x < grid_width)
):
_, (_, width, _) = border_list[skipped_rows + y][x]
result = max(result, width)
return result / 2
def add_vertical(x, y):
score, (style, width, color) = vertical_borders[skipped_rows + y][x]
if width == 0 or color.alpha == 0:
return
half_width = width / 2
pos_x = column_positions[x]
pos_y_1 = row_positions[y] - half_max_width(horizontal_borders, [
(y, x - 1), (y, x)], vertical=False)
pos_y_2 = row_positions[y + 1] + half_max_width(horizontal_borders, [
(y + 1, x - 1), (y + 1, x)], vertical=False)
edge_1 = (pos_x - half_width, pos_y_1), (pos_x - half_width, pos_y_2)
edge_2 = (pos_x + half_width, pos_y_1), (pos_x + half_width, pos_y_2)
segments.append((score, style, width, color, 'left', edge_1, edge_2))
def add_horizontal(x, y):
score, (style, width, color) = horizontal_borders[skipped_rows + y][x]
if width == 0 or color.alpha == 0:
return
half_width = width / 2
pos_y = row_positions[y]
# TODO: change signs for rtl when we support rtl tables?
pos_x_1 = column_positions[x] - half_max_width(vertical_borders, [
(y - 1, x), (y, x)])
pos_x_2 = column_positions[x + 1] + half_max_width(vertical_borders, [
(y - 1, x + 1), (y, x + 1)])
edge_1 = (pos_x_1, pos_y - half_width), (pos_x_2, pos_y - half_width)
edge_2 = (pos_x_1, pos_y + half_width), (pos_x_2, pos_y + half_width)
segments.append((score, style, width, color, 'top', edge_1, edge_2))
for x in xrange(grid_width):
add_horizontal(x, 0)
for y in xrange(grid_height):
add_vertical(0, y)
for x in xrange(grid_width):
add_vertical(x + 1, y)
add_horizontal(x, y + 1)
# Sort bigger scores last (painted later, on top)
# Since the number of different scores is expected to be small compared
# to the number of segments, there should be little changes and Timsort
# should be closer to O(n) than O(n * log(n))
segments.sort(key=operator.itemgetter(0))
for segment in segments:
draw_border_segment(context, enable_hinting, *segment[1:])
def draw_replacedbox(context, box):
"""Draw the given :class:`boxes.ReplacedBox` to a ``cairo.context``."""
if box.style.visibility == 'hidden':
return
x, y = box.content_box_x(), box.content_box_y()
width, height = box.width, box.height
pattern, intrinsic_width, intrinsic_height = box.replacement
scale_width = width / intrinsic_width
scale_height = height / intrinsic_height
# Draw nothing for width:0 or height:0
if scale_width != 0 and scale_height != 0:
with stacked(context):
context.translate(x, y)
context.rectangle(0, 0, width, height)
context.clip()
context.scale(scale_width, scale_height)
# The same image/pattern may have been used in a
# repeating background.
pattern.set_extend(cairo.EXTEND_NONE)
pattern.set_filter(IMAGE_RENDERING_TO_FILTER[
box.style.image_rendering])
context.set_source(pattern)
context.paint()
# Make sure `pattern` is garbage collected. If a surface for a SVG image
# is still alive by the time we call show_page(), cairo will rasterize
# the image instead writing vectors.
# Use a unique string that can be traced back here.
# Replaced boxes are atomic, so they should only ever be drawn once.
# Use an object incompatible with the usual 3-tuple to cause an exception
# if this box is used more than that.
box.replacement = 'Removed to work around cairo’s behavior'
def draw_inline_level(context, page, box, enable_hinting):
if isinstance(box, StackingContext):
stacking_context = box
assert isinstance(stacking_context.box, boxes.InlineBlockBox)
draw_stacking_context(context, stacking_context, enable_hinting)
else:
draw_box_background(context, page, box, enable_hinting)
draw_border(context, box, enable_hinting)
if isinstance(box, (boxes.InlineBox, boxes.LineBox)):
for child in box.children:
if isinstance(child, boxes.TextBox):
draw_text(context, child, enable_hinting)
else:
draw_inline_level(context, page, child, enable_hinting)
elif isinstance(box, boxes.InlineReplacedBox):
draw_replacedbox(context, box)
else:
assert isinstance(box, boxes.TextBox)
# Should only happen for list markers
draw_text(context, box, enable_hinting)
def draw_text(context, textbox, enable_hinting):
"""Draw ``textbox`` to a ``cairo.Context`` from ``PangoCairo.Context``."""
# Pango crashes with font-size: 0
assert textbox.style.font_size
if textbox.style.visibility == 'hidden':
return
context.move_to(textbox.position_x, textbox.position_y + textbox.baseline)
context.set_source_rgba(*textbox.style.color)
show_first_line(context, textbox.pango_layout, enable_hinting)
values = textbox.style.text_decoration
if 'overline' in values:
draw_text_decoration(context, textbox,
textbox.baseline - 0.15 * textbox.style.font_size,
enable_hinting)
elif 'underline' in values:
draw_text_decoration(context, textbox,
textbox.baseline + 0.15 * textbox.style.font_size,
enable_hinting)
elif 'line-through' in values:
draw_text_decoration(context, textbox, textbox.height * 0.5,
enable_hinting)
def draw_text_decoration(context, textbox, offset_y, enable_hinting):
"""Draw text-decoration of ``textbox`` to a ``cairo.Context``."""
with stacked(context):
if enable_hinting:
context.set_antialias(cairo.ANTIALIAS_NONE)
context.set_source_rgba(*textbox.style.color)
context.set_line_width(1) # TODO: make this proportional to font_size?
context.move_to(textbox.position_x, textbox.position_y + offset_y)
context.rel_line_to(textbox.width, 0)
context.stroke()
def apply_2d_transforms(context, box):
# "Transforms apply to block-level and atomic inline-level elements,
# but do not apply to elements which may be split into
# multiple inline-level boxes."
# http://www.w3.org/TR/css3-2d-transforms/#introduction
if box.style.transform and not isinstance(box, boxes.InlineBox):
border_width = box.border_width()
border_height = box.border_height()
origin_x, origin_y = box.style.transform_origin
origin_x = percentage(origin_x, border_width)
origin_y = percentage(origin_y, border_height)
origin_x += box.border_box_x()
origin_y += box.border_box_y()
context.translate(origin_x, origin_y)
for name, args in box.style.transform:
if name == 'scale':
context.scale(*args)
elif name == 'rotate':
context.rotate(args)
elif name == 'translate':
translate_x, translate_y = args
context.translate(
percentage(translate_x, border_width),
percentage(translate_y, border_height),
)
else:
if name == 'skewx':
args = (1, 0, math.tan(args), 1, 0, 0)
elif name == 'skewy':
args = (1, math.tan(args), 0, 1, 0, 0)
else:
assert name == 'matrix'
context.transform(cairo.Matrix(*args))
context.translate(-origin_x, -origin_y)