mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
Bug 700926. Python script to generate reftest reference pages. r=roc
This commit is contained in:
Nicholas Cameron
parent
3073a40ec3
commit
a9561d28b4
347
layout/reftests/border-image/gen-refs.py
Normal file
347
layout/reftests/border-image/gen-refs.py
Normal file
@ -0,0 +1,347 @@
|
||||
# This Source Code Form is subject to the terms of the Mozilla Public
|
||||
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
# Generates tables of background images which correspond with border images for
|
||||
# creating reftests. Input is the filename containing input defined below (a subset
|
||||
# of the allowed CSS border properties). An html representation of a table is
|
||||
# output to stdout.
|
||||
#
|
||||
# Usage: python gen-refs.py input_filename
|
||||
#
|
||||
# Input must take the form (order is not important, nothing is optional, distance in order top, right, bottom, left):
|
||||
# width: p;
|
||||
# height: p;
|
||||
# border-width: p;
|
||||
# border-image-source: ...;
|
||||
# border-image-slice: p p p p;
|
||||
# note that actually border-image-slice takes numbers without px, which represent pixels anyway (or at least coords)
|
||||
# border-image-width: np np np np;
|
||||
# border-image-repeat: stretch | repeat | round;
|
||||
# border-image-outset: np np np np;
|
||||
#
|
||||
# where:
|
||||
# p ::= n'px'
|
||||
# np ::= n | p
|
||||
#
|
||||
# Assumes there is no intrinsic size for the border-image-source, so uses
|
||||
# the size of the border image area.
|
||||
|
||||
import sys
|
||||
|
||||
class Point:
|
||||
def __init__(self, w=0, h=0):
|
||||
self.x = w
|
||||
self.y = h
|
||||
class Size:
|
||||
def __init__(self, w=0, h=0):
|
||||
self.width = w
|
||||
self.height = h
|
||||
class Rect:
|
||||
def __init__(self, x=0, y=0, x2=0, y2=0):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.x2 = x2
|
||||
self.y2 = y2
|
||||
def width(self):
|
||||
return self.x2 - self.x
|
||||
def height(self):
|
||||
return self.y2 - self.y
|
||||
|
||||
class Props:
|
||||
def __init__(self):
|
||||
self.size = Size()
|
||||
|
||||
class np:
|
||||
def __init__(self, n, p):
|
||||
self.n = n
|
||||
self.p = p
|
||||
|
||||
def get_absolute(self, ref):
|
||||
if not self.p == 0:
|
||||
return self.p
|
||||
return self.n * ref
|
||||
|
||||
def parse_p(tok):
|
||||
if tok[-2:] == "px":
|
||||
return float(tok[:-2])
|
||||
print "Whoops, not a pixel value " + tok
|
||||
|
||||
def parse_np(tok):
|
||||
if tok[-2:] == "px":
|
||||
return np(0, float(tok[:-2]))
|
||||
return np(float(tok), 0)
|
||||
|
||||
def parse(filename):
|
||||
f = open(filename, "r")
|
||||
props = Props()
|
||||
for l in f:
|
||||
l = l.strip()
|
||||
if not l[-1] == ";":
|
||||
continue
|
||||
toks = l[:-1].split()
|
||||
if toks[0] == "border-width:":
|
||||
props.width = parse_p(toks[1])
|
||||
if toks[0] == "height:":
|
||||
props.size.height = parse_p(toks[1])
|
||||
if toks[0] == "width:":
|
||||
props.size.width = parse_p(toks[1])
|
||||
if toks[0] == "border-image-source:":
|
||||
props.source = l[l.find(":")+1:l.rfind(";")].strip()
|
||||
if toks[0] == "border-image-repeat:":
|
||||
props.repeat = toks[1]
|
||||
if toks[0] == "border-image-slice:":
|
||||
props.slice = map(parse_p, toks[1:5])
|
||||
if toks[0] == "border-image-width:":
|
||||
props.image_width = map(parse_np, toks[1:5])
|
||||
if toks[0] == "border-image-outset:":
|
||||
props.outset = map(parse_np, toks[1:5])
|
||||
f.close()
|
||||
return props
|
||||
|
||||
# the result of normalisation is that all sizes are in pixels and the size,
|
||||
# widths, and outset have been normalised to a size and width - the former is
|
||||
# the element's interior, the latter is the width of the drawn border.
|
||||
def normalise(props):
|
||||
result = Props()
|
||||
result.source = props.source
|
||||
result.repeat = props.repeat
|
||||
result.width = map(lambda x: x.get_absolute(props.width), props.image_width)
|
||||
outsets = map(lambda x: x.get_absolute(props.width), props.outset)
|
||||
result.size.width = props.size.width + 2*props.width + outsets[1] + outsets[3]
|
||||
result.size.height = props.size.height + 2*props.width + outsets[0] + outsets[2]
|
||||
result.slice = props.slice
|
||||
for i in [0,2]:
|
||||
if result.slice[i] > result.size.height:
|
||||
result.slice[i] = result.size.height
|
||||
if result.slice[i+1] > result.size.width:
|
||||
result.slice[i+1] = result.size.width
|
||||
|
||||
return result
|
||||
|
||||
def check_parse(props):
|
||||
if not hasattr(props, 'source'):
|
||||
print "missing border-image-source"
|
||||
return False
|
||||
if not hasattr(props.size, 'width'):
|
||||
print "missing width"
|
||||
return False
|
||||
if not hasattr(props.size, 'height'):
|
||||
print "missing height"
|
||||
return False
|
||||
if not hasattr(props, 'width'):
|
||||
print "missing border-width"
|
||||
return False
|
||||
if not hasattr(props, 'image_width'):
|
||||
print "missing border-image-width"
|
||||
return False
|
||||
if not hasattr(props, 'slice'):
|
||||
print "missing border-image-slice"
|
||||
return False
|
||||
if not hasattr(props, 'repeat') or (props.repeat not in ["stretch", "repeat", "round"]):
|
||||
print "missing or incorrect border-image-repeat '" + props.repeat + "'"
|
||||
return False
|
||||
if not hasattr(props, 'outset'):
|
||||
print "missing border-image-outset"
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
def check_normalise(props):
|
||||
if not hasattr(props, 'source'):
|
||||
print "missing border-image-source"
|
||||
return False
|
||||
if not hasattr(props.size, 'width'):
|
||||
print "missing width"
|
||||
return False
|
||||
if not hasattr(props.size, 'height'):
|
||||
print "missing height"
|
||||
return False
|
||||
if not hasattr(props, 'slice'):
|
||||
print "missing border-image-slice"
|
||||
return False
|
||||
if not hasattr(props, 'repeat') or (props.repeat not in ["stretch", "repeat", "round"]):
|
||||
print "missing or incorrect border-image-repeat '" + props.repeat + "'"
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
class Tile:
|
||||
def __init__(self):
|
||||
self.slice = Rect()
|
||||
self.border_width = Rect()
|
||||
|
||||
# throughout, we will use arrays for nine-patches, the indices correspond thusly:
|
||||
# 0 1 2
|
||||
# 3 4 5
|
||||
# 6 7 8
|
||||
|
||||
# Compute the source tiles' slice and border-width sizes
|
||||
def make_src_tiles():
|
||||
tiles = [Tile() for i in range(9)]
|
||||
|
||||
rows = [range(3*i, 3*(i+1)) for i in range(3)]
|
||||
cols = [[i, i+3, i+6] for i in range(3)]
|
||||
|
||||
row_limits_slice = [0, props.slice[3], props.size.width - props.slice[1], props.size.width]
|
||||
row_limits_width = [0, props.width[3], props.size.width - props.width[1], props.size.width]
|
||||
for r in range(3):
|
||||
for t in [tiles[i] for i in cols[r]]:
|
||||
t.slice.x = row_limits_slice[r]
|
||||
t.slice.x2 = row_limits_slice[r+1]
|
||||
t.border_width.x = row_limits_width[r]
|
||||
t.border_width.x2 = row_limits_width[r+1]
|
||||
|
||||
col_limits_slice = [0, props.slice[0], props.size.height - props.slice[2], props.size.height]
|
||||
col_limits_width = [0, props.width[0], props.size.height - props.width[2], props.size.height]
|
||||
for c in range(3):
|
||||
for t in [tiles[i] for i in rows[c]]:
|
||||
t.slice.y = col_limits_slice[c]
|
||||
t.slice.y2 = col_limits_slice[c+1]
|
||||
t.border_width.y = col_limits_width[c]
|
||||
t.border_width.y2 = col_limits_width[c+1]
|
||||
|
||||
return tiles
|
||||
|
||||
def compute(props):
|
||||
tiles = make_src_tiles()
|
||||
|
||||
# corners scale easy
|
||||
for t in [tiles[i] for i in [0, 2, 6, 8]]:
|
||||
t.scale = Point(t.border_width.width()/t.slice.width(), t.border_width.height()/t.slice.height())
|
||||
# edges are by their secondary dimension
|
||||
for t in [tiles[i] for i in [1, 7]]:
|
||||
t.scale = Point(t.border_width.height()/t.slice.height(), t.border_width.height()/t.slice.height())
|
||||
for t in [tiles[i] for i in [3, 5]]:
|
||||
t.scale = Point(t.border_width.width()/t.slice.width(), t.border_width.width()/t.slice.width())
|
||||
# the middle is scaled by the factors for the top and left edges
|
||||
tiles[4].scale = Point(tiles[1].scale.x, tiles[3].scale.y)
|
||||
|
||||
# the size of a source tile for the middle section
|
||||
src_tile_size = Size(tiles[4].slice.width()*tiles[4].scale.x, tiles[4].slice.height()*tiles[4].scale.y)
|
||||
|
||||
# the size of a single destination tile in the central part
|
||||
dest_tile_size = Size()
|
||||
if props.repeat == "stretch":
|
||||
dest_tile_size.width = tiles[4].border_width.width()
|
||||
dest_tile_size.height = tiles[4].border_width.height()
|
||||
for t in [tiles[i] for i in [1, 7]]:
|
||||
t.scale.x = t.border_width.width()/t.slice.width()
|
||||
for t in [tiles[i] for i in [3, 5]]:
|
||||
t.scale.y = t.border_width.height()/t.slice.height()
|
||||
elif props.repeat == "repeat":
|
||||
dest_tile_size = src_tile_size
|
||||
elif props.repeat == "round":
|
||||
dest_tile_size.width = tiles[4].border_width.width() / math.ceil(tiles[4].border_width.width() / src_tile_size.width)
|
||||
dest_tile_size.height = tiles[4].border_width.height() / math.ceil(tiles[4].border_width.height() / src_tile_size.height)
|
||||
for t in [tiles[i] for i in [1, 4, 7]]:
|
||||
t.scale.x = dest_tile_size.width/t.slice.width()
|
||||
for t in [tiles[i] for i in [3, 4, 5]]:
|
||||
t.scale.y = dest_tile_size.height/t.slice.height()
|
||||
else:
|
||||
print "Whoops, invalid border-image-repeat value"
|
||||
|
||||
# catch overlapping slices. Its easier to deal with it here than to catch
|
||||
# earlier and have to avoid all the divide by zeroes above
|
||||
for t in tiles:
|
||||
if t.slice.width() < 0:
|
||||
t.scale.x = 0
|
||||
if t.slice.height() < 0:
|
||||
t.scale.y = 0
|
||||
|
||||
tiles_h = int(math.ceil(tiles[4].border_width.width()/dest_tile_size.width)+2)
|
||||
tiles_v = int(math.ceil(tiles[4].border_width.height()/dest_tile_size.height)+2)
|
||||
|
||||
# if border-image-repeat: repeat, then we will later center the tiles, that
|
||||
# means we need an extra tile for the two 'half' tiles at either end
|
||||
if props.repeat == "repeat":
|
||||
if tiles_h % 2 == 0:
|
||||
tiles_h += 1
|
||||
if tiles_v % 2 == 0:
|
||||
tiles_v += 1
|
||||
dest_tiles = [Tile() for i in range(tiles_h * tiles_v)]
|
||||
|
||||
# corners
|
||||
corners = [(0, 0), (tiles_h-1, 2), (tiles_v*(tiles_h-1), 6), (tiles_v*tiles_h-1, 8)]
|
||||
for d,s in corners:
|
||||
dest_tiles[d].size = Size(tiles[s].scale.x*props.size.width, tiles[s].scale.y*props.size.height)
|
||||
dest_tiles[d].dest_size = Size(tiles[s].border_width.width(), tiles[s].border_width.height())
|
||||
dest_tiles[0].offset = Point(0, 0)
|
||||
dest_tiles[tiles_h-1].offset = Point(tiles[2].border_width.width() - dest_tiles[tiles_h-1].size.width, 0)
|
||||
dest_tiles[tiles_v*(tiles_h-1)].offset = Point(0, tiles[6].border_width.height() - dest_tiles[tiles_v*(tiles_h-1)].size.height)
|
||||
dest_tiles[tiles_v*tiles_h-1].offset = Point(tiles[8].border_width.width() - dest_tiles[tiles_h*tiles_v-1].size.width, tiles[8].border_width.height() - dest_tiles[tiles_h*tiles_v-1].size.height)
|
||||
|
||||
# horizontal edges
|
||||
for i in range(1, tiles_h-1):
|
||||
dest_tiles[i].size = Size(tiles[1].scale.x*props.size.width, tiles[1].scale.y*props.size.height)
|
||||
dest_tiles[(tiles_v-1)*tiles_h + i].size = Size(tiles[7].scale.x*props.size.width, tiles[7].scale.y*props.size.height)
|
||||
dest_tiles[i].dest_size = Size(dest_tile_size.width, tiles[1].border_width.height())
|
||||
dest_tiles[(tiles_v-1)*tiles_h + i].dest_size = Size(dest_tile_size.width, tiles[7].border_width.height())
|
||||
dest_tiles[i].offset = Point(-tiles[1].scale.x*tiles[1].slice.x, -tiles[1].scale.y*tiles[1].slice.y)
|
||||
dest_tiles[(tiles_v-1)*tiles_h + i].offset = Point(-tiles[7].scale.x*tiles[7].slice.x, -tiles[7].scale.y*tiles[7].slice.y)
|
||||
|
||||
# vertical edges
|
||||
for i in range(1, tiles_v-1):
|
||||
dest_tiles[i*tiles_h].size = Size(tiles[3].scale.x*props.size.width, tiles[3].scale.y*props.size.height)
|
||||
dest_tiles[(i+1)*tiles_h-1].size = Size(tiles[5].scale.x*props.size.width, tiles[5].scale.y*props.size.height)
|
||||
dest_tiles[i*tiles_h].dest_size = Size(tiles[3].border_width.width(), dest_tile_size.height)
|
||||
dest_tiles[(i+1)*tiles_h-1].dest_size = Size(tiles[5].border_width.width(), dest_tile_size.height)
|
||||
dest_tiles[i*tiles_h].offset = Point(-tiles[3].scale.x*tiles[3].slice.x, -tiles[3].scale.y*tiles[3].slice.y)
|
||||
dest_tiles[(i+1)*tiles_h-1].offset = Point(-tiles[5].scale.x*tiles[5].slice.x, -tiles[5].scale.y*tiles[5].slice.y)
|
||||
|
||||
# middle
|
||||
for i in range(1, tiles_v-1):
|
||||
for j in range(1, tiles_h-1):
|
||||
dest_tiles[i*tiles_h+j].size = Size(tiles[4].scale.x*props.size.width, tiles[4].scale.y*props.size.height)
|
||||
dest_tiles[i*tiles_h+j].offset = Point(-tiles[4].scale.x*tiles[4].slice.x, -tiles[4].scale.y*tiles[4].slice.y)
|
||||
dest_tiles[i*tiles_h+j].dest_size = dest_tile_size
|
||||
|
||||
# edge and middle tiles are centered with border-image-repeat: repeat
|
||||
# we need to change the offset to take account of this and change the dest_size
|
||||
# of the tiles at the sides of the edges if they are clipped
|
||||
if props.repeat == "repeat":
|
||||
diff_h = ((tiles_h-2)*dest_tile_size.width - tiles[4].border_width.width()) / 2
|
||||
diff_v = ((tiles_v-2)*dest_tile_size.height - tiles[4].border_width.height()) / 2
|
||||
for i in range(0, tiles_h):
|
||||
dest_tiles[tiles_h + i].dest_size.height -= diff_v
|
||||
dest_tiles[tiles_h + i].offset.y -= diff_v #* tiles[4].scale.y
|
||||
dest_tiles[(tiles_v-2)*tiles_h + i].dest_size.height -= diff_v
|
||||
for i in range(0, tiles_v):
|
||||
dest_tiles[i*tiles_h + 1].dest_size.width -= diff_h
|
||||
dest_tiles[i*tiles_h + 1].offset.x -= diff_h #* tiles[4].scale.x
|
||||
dest_tiles[(i+1)*tiles_h-2].dest_size.width -= diff_h
|
||||
|
||||
# output the table to simulate the border
|
||||
print "<table>"
|
||||
for i in range(tiles_h):
|
||||
print "<col style=\"width: " + str(dest_tiles[i].dest_size.width) + "px;\">"
|
||||
for i in range(tiles_v):
|
||||
print "<tr style=\"height: " + str(dest_tiles[i*tiles_h].dest_size.height) + "px;\">"
|
||||
for j in range(tiles_h):
|
||||
width = dest_tiles[i*tiles_h+j].size.width
|
||||
height = dest_tiles[i*tiles_h+j].size.height
|
||||
# catch any tiles with negative widths/heights
|
||||
# this happends when the total of the border-image-slices > borde drawing area
|
||||
if width <= 0 or height <= 0:
|
||||
print " <td style=\"background: white;\"></td>"
|
||||
else:
|
||||
print " <td style=\"background-image: " + props.source + "; background-size: " + str(width) + "px " + str(height) + "px; background-position: " + str(dest_tiles[i*tiles_h+j].offset.x) + "px " + str(dest_tiles[i*tiles_h+j].offset.y) + "px;\"></td>"
|
||||
print "</tr>"
|
||||
print "</table>"
|
||||
|
||||
|
||||
# start here
|
||||
args = sys.argv[1:]
|
||||
if len(args) == 0:
|
||||
print "whoops: no source file"
|
||||
exit(1)
|
||||
|
||||
|
||||
props = parse(args[0])
|
||||
if not check_parse(props):
|
||||
print dir(props)
|
||||
exit(1)
|
||||
props = normalise(props)
|
||||
if not check_normalise(props):
|
||||
exit(1)
|
||||
compute(props)
|
||||
Loading…
Reference in New Issue
Block a user