mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-03-17 12:28:39 -05:00
a8bdd536c8
suite. In a dramatic break with tradition, I'm actually checking in the resulting icon files as well as the script that generates them, because the script requires Python and ImageMagick and I don't think it's reasonable to require that much extra infrastructure on everyone checking out from Subversion. The new icons should be _almost_ indistinguishable from the old ones, at least at the 32x32 resolution. The immediately visible change is that all the icons now come in 16x16, 32x32 and 48x48 formats, in both 16 colours and monochrome, instead of an ad-hoc mixture of whichever ones I could be bothered to draw. The same code can also be adapted to generate icons for the GTK port (although icons for the running programs don't seem to be supported by GTK 1 - another reason to upgrade to GTK 2!). [originally from svn r7063]
995 lines
29 KiB
Python
Executable File
995 lines
29 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
import math
|
|
|
|
# Python code which draws the PuTTY icon components at a range of
|
|
# sizes.
|
|
|
|
# TODO
|
|
# ----
|
|
#
|
|
# - use of alpha blending
|
|
# + try for variable-transparency borders
|
|
#
|
|
# - can we integrate the Mac icons into all this? Do we want to?
|
|
|
|
def pixel(x, y, colour, canvas):
|
|
canvas[(int(x),int(y))] = colour
|
|
|
|
def overlay(src, x, y, dst):
|
|
x = int(x)
|
|
y = int(y)
|
|
for (sx, sy), colour in src.items():
|
|
dst[sx+x, sy+y] = blend(colour, dst.get((sx+x, sy+y), cT))
|
|
|
|
def finalise(canvas):
|
|
for k in canvas.keys():
|
|
canvas[k] = finalisepix(canvas[k])
|
|
|
|
def bbox(canvas):
|
|
minx, miny, maxx, maxy = None, None, None, None
|
|
for (x, y) in canvas.keys():
|
|
if minx == None:
|
|
minx, miny, maxx, maxy = x, y, x+1, y+1
|
|
else:
|
|
minx = min(minx, x)
|
|
miny = min(miny, y)
|
|
maxx = max(maxx, x+1)
|
|
maxy = max(maxy, y+1)
|
|
return (minx, miny, maxx, maxy)
|
|
|
|
def topy(canvas):
|
|
miny = {}
|
|
for (x, y) in canvas.keys():
|
|
miny[x] = min(miny.get(x, y), y)
|
|
return miny
|
|
|
|
def render(canvas, minx, miny, maxx, maxy):
|
|
w = maxx - minx
|
|
h = maxy - miny
|
|
ret = []
|
|
for y in range(h):
|
|
ret.append([outpix(cT)] * w)
|
|
for (x, y), colour in canvas.items():
|
|
if x >= minx and x < maxx and y >= miny and y < maxy:
|
|
ret[y-miny][x-minx] = outpix(colour)
|
|
return ret
|
|
|
|
# Code to actually draw pieces of icon. These don't generally worry
|
|
# about positioning within a canvas; they just draw at a standard
|
|
# location, return some useful coordinates, and leave composition
|
|
# to other pieces of code.
|
|
|
|
sqrthash = {}
|
|
def memoisedsqrt(x):
|
|
if not sqrthash.has_key(x):
|
|
sqrthash[x] = math.sqrt(x)
|
|
return sqrthash[x]
|
|
|
|
BR, TR, BL, TL = range(4) # enumeration of quadrants for border()
|
|
|
|
def border(canvas, thickness, squarecorners):
|
|
# I haven't yet worked out exactly how to do borders in a
|
|
# properly alpha-blended fashion.
|
|
#
|
|
# When you have two shades of dark available (half-dark H and
|
|
# full-dark F), the right sequence of circular border sections
|
|
# around a pixel x starts off with these two layouts:
|
|
#
|
|
# H F
|
|
# HxH FxF
|
|
# H F
|
|
#
|
|
# Where it goes after that I'm not entirely sure, but I'm
|
|
# absolutely sure those are the right places to start. However,
|
|
# every automated algorithm I've tried has always started off
|
|
# with the two layouts
|
|
#
|
|
# H HHH
|
|
# HxH HxH
|
|
# H HHH
|
|
#
|
|
# which looks much worse. This is true whether you do
|
|
# pixel-centre sampling (define an inner circle and an outer
|
|
# circle with radii differing by 1, set any pixel whose centre
|
|
# is inside the inner circle to F, any pixel whose centre is
|
|
# outside the outer one to nothing, interpolate between the two
|
|
# and round sensibly), _or_ whether you plot a notional circle
|
|
# of a given radius and measure the actual _proportion_ of each
|
|
# pixel square taken up by it.
|
|
#
|
|
# It's not clear what I should be doing to prevent this. One
|
|
# option is to attempt error-diffusion: Ian Jackson proved on
|
|
# paper that if you round each pixel's ideal value to the
|
|
# nearest of the available output values, then measure the
|
|
# error at each pixel, propagate that error outwards into the
|
|
# original values of the surrounding pixels, and re-round
|
|
# everything, you do get the correct second stage. However, I
|
|
# haven't tried it at a proper range of radii.
|
|
#
|
|
# Another option is that the automated mechanisms described
|
|
# above would be entirely adequate if it weren't for the fact
|
|
# that the human visual centres are adapted to detect
|
|
# horizontal and vertical lines in particular, so the only
|
|
# place you have to behave a bit differently is at the ends of
|
|
# the top and bottom row of pixels in the circle, and the top
|
|
# and bottom of the extreme columns.
|
|
#
|
|
# For the moment, what I have below is a very simple mechanism
|
|
# which always uses only one alpha level for any given border
|
|
# thickness, and which seems to work well enough for Windows
|
|
# 16-colour icons. Everything else will have to wait.
|
|
|
|
thickness = memoisedsqrt(thickness)
|
|
|
|
if thickness < 0.9:
|
|
darkness = 0.5
|
|
else:
|
|
darkness = 1
|
|
if thickness < 1: thickness = 1
|
|
thickness = round(thickness - 0.5) + 0.3
|
|
|
|
dmax = int(round(thickness))
|
|
if dmax < thickness: dmax = dmax + 1
|
|
|
|
cquadrant = [[0] * (dmax+1) for x in range(dmax+1)]
|
|
squadrant = [[0] * (dmax+1) for x in range(dmax+1)]
|
|
|
|
for x in range(dmax+1):
|
|
for y in range(dmax+1):
|
|
if max(x, y) < thickness:
|
|
squadrant[x][y] = darkness
|
|
if memoisedsqrt(x*x+y*y) < thickness:
|
|
cquadrant[x][y] = darkness
|
|
|
|
bvalues = {}
|
|
for (x, y), colour in canvas.items():
|
|
for dx in range(-dmax, dmax+1):
|
|
for dy in range(-dmax, dmax+1):
|
|
quadrant = 2 * (dx < 0) + (dy < 0)
|
|
if (x, y, quadrant) in squarecorners:
|
|
bval = squadrant[abs(dx)][abs(dy)]
|
|
else:
|
|
bval = cquadrant[abs(dx)][abs(dy)]
|
|
if bvalues.get((x+dx,y+dy),0) < bval:
|
|
bvalues[(x+dx,y+dy)] = bval
|
|
|
|
for (x, y), value in bvalues.items():
|
|
if not canvas.has_key((x,y)):
|
|
canvas[(x,y)] = dark(value)
|
|
|
|
def sysbox(size):
|
|
canvas = {}
|
|
|
|
# The system box of the computer.
|
|
|
|
height = int(round(3*size))
|
|
width = int(round(17*size))
|
|
depth = int(round(2*size))
|
|
highlight = int(round(1*size))
|
|
bothighlight = int(round(0.49*size))
|
|
|
|
floppystart = int(round(19*size)) # measured in half-pixels
|
|
floppyend = int(round(29*size)) # measured in half-pixels
|
|
floppybottom = height - bothighlight
|
|
floppyrheight = 0.7 * size
|
|
floppyheight = int(round(floppyrheight))
|
|
if floppyheight < 1:
|
|
floppyheight = 1
|
|
floppytop = floppybottom - floppyheight
|
|
|
|
# The front panel is rectangular.
|
|
for x in range(width):
|
|
for y in range(height):
|
|
grey = 3
|
|
if x < highlight or y < highlight:
|
|
grey = grey + 1
|
|
if x >= width-highlight or y >= height-bothighlight:
|
|
grey = grey - 1
|
|
if y < highlight and x >= width-highlight:
|
|
v = (highlight-1-y) - (x-(width-highlight))
|
|
if v < 0:
|
|
grey = grey - 1
|
|
elif v > 0:
|
|
grey = grey + 1
|
|
if y >= floppytop and y < floppybottom and \
|
|
2*x+2 > floppystart and 2*x < floppyend:
|
|
if 2*x >= floppystart and 2*x+2 <= floppyend and \
|
|
floppyrheight >= 0.7:
|
|
grey = 0
|
|
else:
|
|
grey = 2
|
|
pixel(x, y, greypix(grey/4.0), canvas)
|
|
|
|
# The side panel is a parallelogram.
|
|
for x in range(depth):
|
|
for y in range(height+1):
|
|
pixel(x+width, y-(x+1), greypix(0.5), canvas)
|
|
|
|
# The top panel is another parallelogram.
|
|
for x in range(width-1):
|
|
for y in range(depth):
|
|
grey = 3
|
|
if x >= width-1 - highlight:
|
|
grey = grey + 1
|
|
pixel(x+(y+1), -(y+1), greypix(grey/4.0), canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, [])
|
|
|
|
return canvas
|
|
|
|
def monitor(size):
|
|
canvas = {}
|
|
|
|
# The computer's monitor.
|
|
|
|
height = int(round(9.55*size))
|
|
width = int(round(11*size))
|
|
surround = int(round(1*size))
|
|
botsurround = int(round(2*size))
|
|
sheight = height - surround - botsurround
|
|
swidth = width - 2*surround
|
|
depth = int(round(2*size))
|
|
highlight = int(round(math.sqrt(size)))
|
|
shadow = int(round(0.55*size))
|
|
|
|
# The front panel is rectangular.
|
|
for x in range(width):
|
|
for y in range(height):
|
|
if x >= surround and y >= surround and \
|
|
x < surround+swidth and y < surround+sheight:
|
|
# Screen.
|
|
sx = (float(x-surround) - swidth/3) / swidth
|
|
sy = (float(y-surround) - sheight/3) / sheight
|
|
shighlight = 1.0 - (sx*sx+sy*sy)*0.27
|
|
pix = bluepix(shighlight)
|
|
if x < surround+shadow or y < surround+shadow:
|
|
pix = blend(cD, pix) # sharp-edged shadow on top and left
|
|
else:
|
|
# Complicated double bevel on the screen surround.
|
|
|
|
# First, the outer bevel. We compute the distance
|
|
# from this pixel to each edge of the front
|
|
# rectangle.
|
|
list = [
|
|
(x, +1),
|
|
(y, +1),
|
|
(width-1-x, -1),
|
|
(height-1-y, -1)
|
|
]
|
|
# Now sort the list to find the distance to the
|
|
# _nearest_ edge, or the two joint nearest.
|
|
list.sort()
|
|
# If there's one nearest edge, that determines our
|
|
# bevel colour. If there are two joint nearest, our
|
|
# bevel colour is their shared one if they agree,
|
|
# and neutral otherwise.
|
|
outerbevel = 0
|
|
if list[0][0] < list[1][0] or list[0][1] == list[1][1]:
|
|
if list[0][0] < highlight:
|
|
outerbevel = list[0][1]
|
|
|
|
# Now, the inner bevel. We compute the distance
|
|
# from this pixel to each edge of the screen
|
|
# itself.
|
|
list = [
|
|
(surround-1-x, -1),
|
|
(surround-1-y, -1),
|
|
(x-(surround+swidth), +1),
|
|
(y-(surround+sheight), +1)
|
|
]
|
|
# Now we sort to find the _maximum_ distance, which
|
|
# conveniently ignores any less than zero.
|
|
list.sort()
|
|
# And now the strategy is pretty much the same as
|
|
# above, only we're working from the opposite end
|
|
# of the list.
|
|
innerbevel = 0
|
|
if list[-1][0] > list[-2][0] or list[-1][1] == list[-2][1]:
|
|
if list[-1][0] >= 0 and list[-1][0] < highlight:
|
|
innerbevel = list[-1][1]
|
|
|
|
# Now we know the adjustment we want to make to the
|
|
# pixel's overall grey shade due to the outer
|
|
# bevel, and due to the inner one. We break a tie
|
|
# in favour of a light outer bevel, but otherwise
|
|
# add.
|
|
grey = 3
|
|
if outerbevel > 0 or outerbevel == innerbevel:
|
|
innerbevel = 0
|
|
grey = grey + outerbevel + innerbevel
|
|
|
|
pix = greypix(grey / 4.0)
|
|
|
|
pixel(x, y, pix, canvas)
|
|
|
|
# The side panel is a parallelogram.
|
|
for x in range(depth):
|
|
for y in range(height):
|
|
pixel(x+width, y-x, greypix(0.5), canvas)
|
|
|
|
# The top panel is another parallelogram.
|
|
for x in range(width):
|
|
for y in range(depth-1):
|
|
pixel(x+(y+1), -(y+1), greypix(0.75), canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, [(0,int(height-1),BL)])
|
|
|
|
return canvas
|
|
|
|
def computer(size):
|
|
# Monitor plus sysbox.
|
|
m = monitor(size)
|
|
s = sysbox(size)
|
|
x = int(round((2+size/(size+1))*size))
|
|
y = int(round(4*size))
|
|
mb = bbox(m)
|
|
sb = bbox(s)
|
|
xoff = sb[0] - mb[0] + x
|
|
yoff = sb[3] - mb[3] - y
|
|
overlay(m, xoff, yoff, s)
|
|
return s
|
|
|
|
def lightning(size):
|
|
canvas = {}
|
|
|
|
# The lightning bolt motif.
|
|
|
|
# We always want this to be an even number of pixels in span.
|
|
width = round(7*size) * 2
|
|
height = round(8*size) * 2
|
|
|
|
# The outer edge of each side of the bolt goes to this point.
|
|
outery = round(8.4*size)
|
|
outerx = round(11*size)
|
|
|
|
# And the inner edge goes to this point.
|
|
innery = height - 1 - outery
|
|
innerx = round(7*size)
|
|
|
|
for y in range(int(height)):
|
|
list = []
|
|
if y <= outery:
|
|
list.append(width-1-int(outerx * float(y) / outery + 0.3))
|
|
if y <= innery:
|
|
list.append(width-1-int(innerx * float(y) / innery + 0.3))
|
|
y0 = height-1-y
|
|
if y0 <= outery:
|
|
list.append(int(outerx * float(y0) / outery + 0.3))
|
|
if y0 <= innery:
|
|
list.append(int(innerx * float(y0) / innery + 0.3))
|
|
list.sort()
|
|
for x in range(int(list[0]), int(list[-1]+1)):
|
|
pixel(x, y, cY, canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, [(int(width-1),0,TR), (0,int(height-1),BL)])
|
|
|
|
return canvas
|
|
|
|
def document(size):
|
|
canvas = {}
|
|
|
|
# The document used in the PSCP/PSFTP icon.
|
|
|
|
width = round(13*size)
|
|
height = round(16*size)
|
|
|
|
lineht = round(1*size)
|
|
if lineht < 1: lineht = 1
|
|
linespc = round(0.7*size)
|
|
if linespc < 1: linespc = 1
|
|
nlines = int((height-linespc)/(lineht+linespc))
|
|
height = nlines*(lineht+linespc)+linespc # round this so it fits better
|
|
|
|
# Start by drawing a big white rectangle.
|
|
for y in range(int(height)):
|
|
for x in range(int(width)):
|
|
pixel(x, y, cW, canvas)
|
|
|
|
# Now draw lines of text.
|
|
for line in range(nlines):
|
|
# Decide where this line of text begins.
|
|
if line == 0:
|
|
start = round(4*size)
|
|
elif line < 5*nlines/7:
|
|
start = round((line - (nlines/7)) * size)
|
|
else:
|
|
start = round(1*size)
|
|
if start < round(1*size):
|
|
start = round(1*size)
|
|
# Decide where it ends.
|
|
endpoints = [10, 8, 11, 6, 5, 7, 5]
|
|
ey = line * 6.0 / (nlines-1)
|
|
eyf = math.floor(ey)
|
|
eyc = math.ceil(ey)
|
|
exf = endpoints[int(eyf)]
|
|
exc = endpoints[int(eyc)]
|
|
if eyf == eyc:
|
|
end = exf
|
|
else:
|
|
end = exf * (eyc-ey) + exc * (ey-eyf)
|
|
end = round(end * size)
|
|
|
|
liney = height - (lineht+linespc) * (line+1)
|
|
for x in range(int(start), int(end)):
|
|
for y in range(int(lineht)):
|
|
pixel(x, y+liney, cK, canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, \
|
|
[(0,0,TL),(int(width-1),0,TR),(0,int(height-1),BL), \
|
|
(int(width-1),int(height-1),BR)])
|
|
|
|
return canvas
|
|
|
|
def hat(size):
|
|
canvas = {}
|
|
|
|
# The secret-agent hat in the Pageant icon.
|
|
|
|
topa = [6]*9+[5,3,1,0,0,1,2,2,1,1,1,9,9,10,10,11,11,12,12]
|
|
topa = [round(x*size) for x in topa]
|
|
botl = round(topa[0]+2.4*math.sqrt(size))
|
|
botr = round(topa[-1]+2.4*math.sqrt(size))
|
|
width = round(len(topa)*size)
|
|
|
|
# Line equations for the top and bottom of the hat brim, in the
|
|
# form y=mx+c. c, of course, needs scaling by size, but m is
|
|
# independent of size.
|
|
brimm = 1.0 / 3.75
|
|
brimtopc = round(4*size/3)
|
|
brimbotc = round(10*size/3)
|
|
|
|
for x in range(int(width)):
|
|
xs = float(x) * (len(topa)-1) / (width-1)
|
|
xf = math.floor(xs)
|
|
xc = math.ceil(xs)
|
|
topf = topa[int(xf)]
|
|
topc = topa[int(xc)]
|
|
if xf == xc:
|
|
top = topf
|
|
else:
|
|
top = topf * (xc-xs) + topc * (xs-xf)
|
|
top = math.floor(top)
|
|
bot = round(botl + (botr-botl) * x/(width-1))
|
|
|
|
for y in range(int(top), int(bot)):
|
|
pixel(x, y, cK, canvas)
|
|
|
|
# Now draw the brim.
|
|
for x in range(int(width)):
|
|
brimtop = brimtopc + brimm * x
|
|
brimbot = brimbotc + brimm * x
|
|
for y in range(int(math.floor(brimtop)), int(math.ceil(brimbot))):
|
|
tophere = max(min(brimtop - y, 1), 0)
|
|
bothere = max(min(brimbot - y, 1), 0)
|
|
grey = bothere - tophere
|
|
# Only draw brim pixels over pixels which are (a) part
|
|
# of the main hat, and (b) not right on its edge.
|
|
if canvas.has_key((x,y)) and \
|
|
canvas.has_key((x,y-1)) and \
|
|
canvas.has_key((x,y+1)) and \
|
|
canvas.has_key((x-1,y)) and \
|
|
canvas.has_key((x+1,y)):
|
|
pixel(x, y, greypix(grey), canvas)
|
|
|
|
return canvas
|
|
|
|
def key(size):
|
|
canvas = {}
|
|
|
|
# The key in the PuTTYgen icon.
|
|
|
|
keyheadw = round(9.5*size)
|
|
keyheadh = round(12*size)
|
|
keyholed = round(4*size)
|
|
keyholeoff = round(2*size)
|
|
# Ensure keyheadh and keyshafth have the same parity.
|
|
keyshafth = round((2*size - (int(keyheadh)&1)) / 2) * 2 + (int(keyheadh)&1)
|
|
keyshaftw = round(18.5*size)
|
|
keyhead = [round(x*size) for x in [12,11,8,10,9,8,11,12]]
|
|
|
|
squarepix = []
|
|
|
|
# Ellipse for the key head, minus an off-centre circular hole.
|
|
for y in range(int(keyheadh)):
|
|
dy = (y-(keyheadh-1)/2.0) / (keyheadh/2.0)
|
|
dyh = (y-(keyheadh-1)/2.0) / (keyholed/2.0)
|
|
for x in range(int(keyheadw)):
|
|
dx = (x-(keyheadw-1)/2.0) / (keyheadw/2.0)
|
|
dxh = (x-(keyheadw-1)/2.0-keyholeoff) / (keyholed/2.0)
|
|
if dy*dy+dx*dx <= 1 and dyh*dyh+dxh*dxh > 1:
|
|
pixel(x + keyshaftw, y, cy, canvas)
|
|
|
|
# Rectangle for the key shaft, extended at the bottom for the
|
|
# key head detail.
|
|
for x in range(int(keyshaftw)):
|
|
top = round((keyheadh - keyshafth) / 2)
|
|
bot = round((keyheadh + keyshafth) / 2)
|
|
xs = float(x) * (len(keyhead)-1) / round((len(keyhead)-1)*size)
|
|
xf = math.floor(xs)
|
|
xc = math.ceil(xs)
|
|
in_head = 0
|
|
if xc < len(keyhead):
|
|
in_head = 1
|
|
yf = keyhead[int(xf)]
|
|
yc = keyhead[int(xc)]
|
|
if xf == xc:
|
|
bot = yf
|
|
else:
|
|
bot = yf * (xc-xs) + yc * (xs-xf)
|
|
for y in range(int(top),int(bot)):
|
|
pixel(x, y, cy, canvas)
|
|
if in_head:
|
|
last = (x, y)
|
|
if x == 0:
|
|
squarepix.append((x, int(top), TL))
|
|
if x == 0:
|
|
squarepix.append(last + (BL,))
|
|
if last != None and not in_head:
|
|
squarepix.append(last + (BR,))
|
|
last = None
|
|
|
|
# And draw a border.
|
|
border(canvas, size, squarepix)
|
|
|
|
return canvas
|
|
|
|
def linedist(x1,y1, x2,y2, x,y):
|
|
# Compute the distance from the point x,y to the line segment
|
|
# joining x1,y1 to x2,y2. Returns the distance vector, measured
|
|
# with x,y at the origin.
|
|
|
|
vectors = []
|
|
|
|
# Special case: if x1,y1 and x2,y2 are the same point, we
|
|
# don't attempt to extrapolate it into a line at all.
|
|
if x1 != x2 or y1 != y2:
|
|
# First, find the nearest point to x,y on the infinite
|
|
# projection of the line segment. So we construct a vector
|
|
# n perpendicular to that segment...
|
|
nx = y2-y1
|
|
ny = x1-x2
|
|
# ... compute the dot product of (x1,y1)-(x,y) with that
|
|
# vector...
|
|
nd = (x1-x)*nx + (y1-y)*ny
|
|
# ... multiply by the vector we first thought of...
|
|
ndx = nd * nx
|
|
ndy = nd * ny
|
|
# ... and divide twice by the length of n.
|
|
ndx = ndx / (nx*nx+ny*ny)
|
|
ndy = ndy / (nx*nx+ny*ny)
|
|
# That gives us a displacement vector from x,y to the
|
|
# nearest point. See if it's within the range of the line
|
|
# segment.
|
|
cx = x + ndx
|
|
cy = y + ndy
|
|
if cx >= min(x1,x2) and cx <= max(x1,x2) and \
|
|
cy >= min(y1,y2) and cy <= max(y1,y2):
|
|
vectors.append((ndx,ndy))
|
|
|
|
# Now we have up to three candidate result vectors: (ndx,ndy)
|
|
# as computed just above, and the two vectors to the ends of
|
|
# the line segment, (x1-x,y1-y) and (x2-x,y2-y). Pick the
|
|
# shortest.
|
|
vectors = vectors + [(x1-x,y1-y), (x2-x,y2-y)]
|
|
bestlen, best = None, None
|
|
for v in vectors:
|
|
vlen = v[0]*v[0]+v[1]*v[1]
|
|
if bestlen == None or bestlen > vlen:
|
|
bestlen = vlen
|
|
best = v
|
|
return best
|
|
|
|
def spanner(size):
|
|
canvas = {}
|
|
|
|
# The spanner in the config box icon.
|
|
|
|
headcentre = 0.5 + round(4*size)
|
|
headradius = headcentre + 0.1
|
|
headhighlight = round(1.5*size)
|
|
holecentre = 0.5 + round(3*size)
|
|
holeradius = round(2*size)
|
|
holehighlight = round(1.5*size)
|
|
shaftend = 0.5 + round(25*size)
|
|
shaftwidth = round(2*size)
|
|
shafthighlight = round(1.5*size)
|
|
cmax = shaftend + shaftwidth
|
|
|
|
# Define three line segments, such that the shortest distance
|
|
# vectors from any point to each of these segments determines
|
|
# everything we need to know about where it is on the spanner
|
|
# shape.
|
|
segments = [
|
|
((0,0), (holecentre, holecentre)),
|
|
((headcentre, headcentre), (headcentre, headcentre)),
|
|
((headcentre+headradius/math.sqrt(2), headcentre+headradius/math.sqrt(2)),
|
|
(cmax, cmax))
|
|
]
|
|
|
|
for y in range(int(cmax)):
|
|
for x in range(int(cmax)):
|
|
vectors = [linedist(a,b,c,d,x,y) for ((a,b),(c,d)) in segments]
|
|
dists = [memoisedsqrt(vx*vx+vy*vy) for (vx,vy) in vectors]
|
|
|
|
# If the distance to the hole line is less than
|
|
# holeradius, we're not part of the spanner.
|
|
if dists[0] < holeradius:
|
|
continue
|
|
# If the distance to the head `line' is less than
|
|
# headradius, we are part of the spanner; likewise if
|
|
# the distance to the shaft line is less than
|
|
# shaftwidth _and_ the resulting shaft point isn't
|
|
# beyond the shaft end.
|
|
if dists[1] > headradius and \
|
|
(dists[2] > shaftwidth or x+vectors[2][0] >= shaftend):
|
|
continue
|
|
|
|
# We're part of the spanner. Now compute the highlight
|
|
# on this pixel. We do this by computing a `slope
|
|
# vector', which points from this pixel in the
|
|
# direction of its nearest edge. We store an array of
|
|
# slope vectors, in polar coordinates.
|
|
angles = [math.atan2(vy,vx) for (vx,vy) in vectors]
|
|
slopes = []
|
|
if dists[0] < holeradius + holehighlight:
|
|
slopes.append(((dists[0]-holeradius)/holehighlight,angles[0]))
|
|
if dists[1]/headradius < dists[2]/shaftwidth:
|
|
if dists[1] > headradius - headhighlight and dists[1] < headradius:
|
|
slopes.append(((headradius-dists[1])/headhighlight,math.pi+angles[1]))
|
|
else:
|
|
if dists[2] > shaftwidth - shafthighlight and dists[2] < shaftwidth:
|
|
slopes.append(((shaftwidth-dists[2])/shafthighlight,math.pi+angles[2]))
|
|
# Now we find the smallest distance in that array, if
|
|
# any, and that gives us a notional position on a
|
|
# sphere which we can use to compute the final
|
|
# highlight level.
|
|
bestdist = None
|
|
bestangle = 0
|
|
for dist, angle in slopes:
|
|
if bestdist == None or bestdist > dist:
|
|
bestdist = dist
|
|
bestangle = angle
|
|
if bestdist == None:
|
|
bestdist = 1.0
|
|
sx = (1.0-bestdist) * math.cos(bestangle)
|
|
sy = (1.0-bestdist) * math.sin(bestangle)
|
|
sz = math.sqrt(1.0 - sx*sx - sy*sy)
|
|
shade = sx-sy+sz / math.sqrt(3) # can range from -1 to +1
|
|
shade = 1.0 - (1-shade)/3
|
|
|
|
pixel(x, y, yellowpix(shade), canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, [])
|
|
|
|
return canvas
|
|
|
|
# Functions to draw entire icons by composing the above components.
|
|
|
|
def xybolt(c1, c2, size, boltoffx=0, boltoffy=0):
|
|
# Two unspecified objects and a lightning bolt.
|
|
|
|
canvas = {}
|
|
w = h = round(32 * size)
|
|
|
|
bolt = lightning(size)
|
|
|
|
# Position c2 against the top right of the icon.
|
|
bb = bbox(c2)
|
|
assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
|
|
overlay(c2, w-bb[2], 0-bb[1], canvas)
|
|
# Position c1 against the bottom left of the icon.
|
|
bb = bbox(c1)
|
|
assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
|
|
overlay(c1, 0-bb[0], h-bb[3], canvas)
|
|
# Place the lightning bolt artistically off-centre. (The
|
|
# rationale for this positioning is that it's centred on the
|
|
# midpoint between the centres of the two monitors in the PuTTY
|
|
# icon proper, but it's not really feasible to _base_ the
|
|
# calculation here on that.)
|
|
bb = bbox(bolt)
|
|
assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
|
|
overlay(bolt, (w-bb[0]-bb[2])/2 - round((1-boltoffx)*size), \
|
|
(h-bb[1]-bb[3])/2 - round((2-boltoffy)*size), canvas)
|
|
|
|
return canvas
|
|
|
|
def putty_icon(size):
|
|
return xybolt(computer(size), computer(size), size)
|
|
|
|
def puttycfg_icon(size):
|
|
w = h = round(32 * size)
|
|
s = spanner(size)
|
|
canvas = putty_icon(size)
|
|
# Centre the spanner.
|
|
bb = bbox(s)
|
|
overlay(s, (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2, canvas)
|
|
return canvas
|
|
|
|
def puttygen_icon(size):
|
|
return xybolt(computer(size), key(size), size, boltoffx=2)
|
|
|
|
def pscp_icon(size):
|
|
return xybolt(document(size), computer(size), size, boltoffx=1)
|
|
|
|
def pterm_icon(size):
|
|
# Just a really big computer.
|
|
|
|
canvas = {}
|
|
w = h = round(32 * size)
|
|
|
|
c = computer(size * 1.4)
|
|
|
|
# Centre c in the return canvas.
|
|
bb = bbox(c)
|
|
assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
|
|
overlay(c, (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2, canvas)
|
|
|
|
return canvas
|
|
|
|
def ptermcfg_icon(size):
|
|
w = h = round(32 * size)
|
|
s = spanner(size)
|
|
canvas = pterm_icon(size)
|
|
# Centre the spanner.
|
|
bb = bbox(s)
|
|
overlay(s, (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2, canvas)
|
|
return canvas
|
|
|
|
def pageant_icon(size):
|
|
# A biggish computer, in a hat.
|
|
|
|
canvas = {}
|
|
w = h = round(32 * size)
|
|
|
|
c = computer(size * 1.3)
|
|
ht = hat(size)
|
|
|
|
cbb = bbox(c)
|
|
hbb = bbox(ht)
|
|
|
|
# Determine the relative y-coordinates of the computer and hat.
|
|
# We just centre the one on the other.
|
|
xrel = (cbb[0]+cbb[2]-hbb[0]-hbb[2])/2
|
|
|
|
# Determine the relative y-coordinates of the computer and hat.
|
|
# We do this by sitting the hat as low down on the computer as
|
|
# possible without any computer showing over the top. To do
|
|
# this we first have to find the minimum x coordinate at each
|
|
# y-coordinate of both components.
|
|
cty = topy(c)
|
|
hty = topy(ht)
|
|
yrelmin = None
|
|
for cx in cty.keys():
|
|
hx = cx - xrel
|
|
assert hty.has_key(hx)
|
|
yrel = cty[cx] - hty[hx]
|
|
if yrelmin == None:
|
|
yrelmin = yrel
|
|
else:
|
|
yrelmin = min(yrelmin, yrel)
|
|
|
|
# Overlay the hat on the computer.
|
|
overlay(ht, xrel, yrelmin, c)
|
|
|
|
# And centre the result in the main icon canvas.
|
|
bb = bbox(c)
|
|
assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
|
|
overlay(c, (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2, canvas)
|
|
|
|
return canvas
|
|
|
|
# Test and output functions.
|
|
|
|
import os
|
|
import sys
|
|
|
|
def testrun(func, fname):
|
|
canvases = []
|
|
for size in [0.5, 0.6, 1.0, 1.2, 1.5, 4.0]:
|
|
canvases.append(func(size))
|
|
wid = 0
|
|
ht = 0
|
|
for canvas in canvases:
|
|
minx, miny, maxx, maxy = bbox(canvas)
|
|
wid = max(wid, maxx-minx+4)
|
|
ht = ht + maxy-miny+4
|
|
block = []
|
|
for canvas in canvases:
|
|
minx, miny, maxx, maxy = bbox(canvas)
|
|
block.extend(render(canvas, minx-2, miny-2, minx-2+wid, maxy+2))
|
|
p = os.popen("convert -depth 8 -size %dx%d rgb:- %s" % (wid,ht,fname), "w")
|
|
assert len(block) == ht
|
|
for line in block:
|
|
assert len(line) == wid
|
|
for r, g, b, a in line:
|
|
# Composite on to orange.
|
|
r = int(round((r * a + 255 * (255-a)) / 255.0))
|
|
g = int(round((g * a + 128 * (255-a)) / 255.0))
|
|
b = int(round((b * a + 0 * (255-a)) / 255.0))
|
|
p.write("%c%c%c" % (r,g,b))
|
|
p.close()
|
|
|
|
def drawicon(func, width, fname, orangebackground = 0):
|
|
canvas = func(width / 32.0)
|
|
finalise(canvas)
|
|
minx, miny, maxx, maxy = bbox(canvas)
|
|
assert minx >= 0 and miny >= 0 and maxx <= width and maxy <= width
|
|
|
|
block = render(canvas, 0, 0, width, width)
|
|
p = os.popen("convert -depth 8 -size %dx%d rgba:- %s" % (width,width,fname), "w")
|
|
assert len(block) == width
|
|
for line in block:
|
|
assert len(line) == width
|
|
for r, g, b, a in line:
|
|
if orangebackground:
|
|
# Composite on to orange.
|
|
r = int(round((r * a + 255 * (255-a)) / 255.0))
|
|
g = int(round((g * a + 128 * (255-a)) / 255.0))
|
|
b = int(round((b * a + 0 * (255-a)) / 255.0))
|
|
a = 255
|
|
p.write("%c%c%c%c" % (r,g,b,a))
|
|
p.close()
|
|
|
|
args = sys.argv[1:]
|
|
|
|
orangebackground = test = 0
|
|
colours = 1 # 0=mono, 1=16col, 2=truecol
|
|
doingargs = 1
|
|
|
|
realargs = []
|
|
for arg in args:
|
|
if doingargs and arg[0] == "-":
|
|
if arg == "-t":
|
|
test = 1
|
|
elif arg == "-it":
|
|
orangebackground = 1
|
|
elif arg == "-2":
|
|
colours = 0
|
|
elif arg == "-T":
|
|
colours = 2
|
|
elif arg == "--":
|
|
doingargs = 0
|
|
else:
|
|
sys.stderr.write("unrecognised option '%s'\n" % arg)
|
|
sys.exit(1)
|
|
else:
|
|
realargs.append(arg)
|
|
|
|
if colours == 0:
|
|
# Monochrome.
|
|
cK=cr=cg=cb=cm=cc=cP=cw=cR=cG=cB=cM=cC=cD = 0
|
|
cY=cy=cW = 1
|
|
cT = -1
|
|
def greypix(value):
|
|
return [cK,cW][int(round(value))]
|
|
def yellowpix(value):
|
|
return [cK,cW][int(round(value))]
|
|
def bluepix(value):
|
|
return cK
|
|
def dark(value):
|
|
return [cT,cK][int(round(value))]
|
|
def blend(col1, col2):
|
|
if col1 == cT:
|
|
return col2
|
|
else:
|
|
return col1
|
|
pixvals = [
|
|
(0x00, 0x00, 0x00, 0xFF), # cK
|
|
(0xFF, 0xFF, 0xFF, 0xFF), # cW
|
|
(0x00, 0x00, 0x00, 0x00), # cT
|
|
]
|
|
def outpix(colour):
|
|
return pixvals[colour]
|
|
def finalisepix(colour):
|
|
return colour
|
|
elif colours == 1:
|
|
# Windows 16-colour palette.
|
|
cK,cr,cg,cy,cb,cm,cc,cP,cw,cR,cG,cY,cB,cM,cC,cW = range(16)
|
|
cT = -1
|
|
cD = -2 # special translucent half-darkening value used internally
|
|
def greypix(value):
|
|
return [cK,cw,cw,cP,cW][int(round(4*value))]
|
|
def yellowpix(value):
|
|
return [cK,cy,cY][int(round(2*value))]
|
|
def bluepix(value):
|
|
return [cK,cb,cB][int(round(2*value))]
|
|
def dark(value):
|
|
return [cT,cD,cK][int(round(2*value))]
|
|
def blend(col1, col2):
|
|
if col1 == cT:
|
|
return col2
|
|
elif col1 == cD:
|
|
return [cK,cK,cK,cK,cK,cK,cK,cw,cK,cr,cg,cy,cb,cm,cc,cw,cD,cD][col2]
|
|
else:
|
|
return col1
|
|
pixvals = [
|
|
(0x00, 0x00, 0x00, 0xFF), # cK
|
|
(0x80, 0x00, 0x00, 0xFF), # cr
|
|
(0x00, 0x80, 0x00, 0xFF), # cg
|
|
(0x80, 0x80, 0x00, 0xFF), # cy
|
|
(0x00, 0x00, 0x80, 0xFF), # cb
|
|
(0x80, 0x00, 0x80, 0xFF), # cm
|
|
(0x00, 0x80, 0x80, 0xFF), # cc
|
|
(0xC0, 0xC0, 0xC0, 0xFF), # cP
|
|
(0x80, 0x80, 0x80, 0xFF), # cw
|
|
(0xFF, 0x00, 0x00, 0xFF), # cR
|
|
(0x00, 0xFF, 0x00, 0xFF), # cG
|
|
(0xFF, 0xFF, 0x00, 0xFF), # cY
|
|
(0x00, 0x00, 0xFF, 0xFF), # cB
|
|
(0xFF, 0x00, 0xFF, 0xFF), # cM
|
|
(0x00, 0xFF, 0xFF, 0xFF), # cC
|
|
(0xFF, 0xFF, 0xFF, 0xFF), # cW
|
|
(0x00, 0x00, 0x00, 0x80), # cD
|
|
(0x00, 0x00, 0x00, 0x00), # cT
|
|
]
|
|
def outpix(colour):
|
|
return pixvals[colour]
|
|
def finalisepix(colour):
|
|
# cD is used internally, but can't be output. Convert to cK.
|
|
if colour == cD:
|
|
return cK
|
|
return colour
|
|
else:
|
|
# True colour.
|
|
cK = (0x00, 0x00, 0x00, 0xFF)
|
|
cr = (0x80, 0x00, 0x00, 0xFF)
|
|
cg = (0x00, 0x80, 0x00, 0xFF)
|
|
cy = (0x80, 0x80, 0x00, 0xFF)
|
|
cb = (0x00, 0x00, 0x80, 0xFF)
|
|
cm = (0x80, 0x00, 0x80, 0xFF)
|
|
cc = (0x00, 0x80, 0x80, 0xFF)
|
|
cP = (0xC0, 0xC0, 0xC0, 0xFF)
|
|
cw = (0x80, 0x80, 0x80, 0xFF)
|
|
cR = (0xFF, 0x00, 0x00, 0xFF)
|
|
cG = (0x00, 0xFF, 0x00, 0xFF)
|
|
cY = (0xFF, 0xFF, 0x00, 0xFF)
|
|
cB = (0x00, 0x00, 0xFF, 0xFF)
|
|
cM = (0xFF, 0x00, 0xFF, 0xFF)
|
|
cC = (0x00, 0xFF, 0xFF, 0xFF)
|
|
cW = (0xFF, 0xFF, 0xFF, 0xFF)
|
|
cD = (0x00, 0x00, 0x00, 0x80)
|
|
cT = (0x00, 0x00, 0x00, 0x00)
|
|
def greypix(value):
|
|
value = max(min(value, 1), 0)
|
|
return (int(round(0xFF*value)),) * 3 + (0xFF,)
|
|
def yellowpix(value):
|
|
value = max(min(value, 1), 0)
|
|
return (int(round(0xFF*value)),) * 2 + (0, 0xFF)
|
|
def bluepix(value):
|
|
value = max(min(value, 1), 0)
|
|
return (0, 0, int(round(0xFF*value)), 0xFF)
|
|
def dark(value):
|
|
value = max(min(value, 1), 0)
|
|
return (0, 0, 0, int(round(0xFF*value)))
|
|
def blend(col1, col2):
|
|
r1,g1,b1,a1 = col1
|
|
r2,g2,b2,a2 = col2
|
|
r = int(round((r1*a1 + r2*(0xFF-a1)) / 255.0))
|
|
g = int(round((g1*a1 + g2*(0xFF-a1)) / 255.0))
|
|
b = int(round((b1*a1 + b2*(0xFF-a1)) / 255.0))
|
|
a = int(round((255*a1 + a2*(0xFF-a1)) / 255.0))
|
|
return r, g, b, a
|
|
def outpix(colour):
|
|
return colour
|
|
if colours == 2:
|
|
# True colour with no alpha blending: we still have to
|
|
# finalise half-dark pixels to black.
|
|
def finalisepix(colour):
|
|
if colour[3] > 0:
|
|
return colour[:3] + (0xFF,)
|
|
return colour
|
|
else:
|
|
def finalisepix(colour):
|
|
return colour
|
|
|
|
if test:
|
|
testrun(eval(realargs[0]), realargs[1])
|
|
else:
|
|
drawicon(eval(realargs[0]), int(realargs[1]), realargs[2], orangebackground)
|