mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-09 17:38:00 +00:00
2ec2b796ed
Most of them are now _mandatory_ P3 scripts, because I'm tired of maintaining everything to be compatible with both versions. The current exceptions are gdb.py (which has to live with whatever gdb gives it), and kh2reg.py (which is actually designed for other people to use, and some of them might still be stuck on P2 for the moment).
1108 lines
37 KiB
Python
Executable File
1108 lines
37 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
from __future__ import division
|
|
|
|
import sys
|
|
import decimal
|
|
import math
|
|
|
|
assert sys.version_info[:2] >= (3,0), "This is Python 3 code"
|
|
|
|
# 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?
|
|
|
|
# Python 3 prefers round-to-even. Emulate Python 2's behaviour instead.
|
|
def round(number):
|
|
return float(
|
|
decimal.Decimal(number).to_integral(rounding=decimal.ROUND_HALF_UP))
|
|
|
|
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 x not in sqrthash:
|
|
sqrthash[x] = math.sqrt(x)
|
|
return sqrthash[x]
|
|
|
|
BR, TR, BL, TL = list(range(4)) # enumeration of quadrants for border()
|
|
|
|
def border(canvas, thickness, squarecorners, out={}):
|
|
# 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
|
|
|
|
out["borderthickness"] = thickness
|
|
|
|
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 (x,y) not in canvas:
|
|
canvas[(x,y)] = dark(value)
|
|
|
|
def sysbox(size, out={}):
|
|
canvas = {}
|
|
|
|
# The system box of the computer.
|
|
|
|
height = int(round(3.6*size))
|
|
width = int(round(16.51*size))
|
|
depth = int(round(2*size))
|
|
highlight = int(round(1*size))
|
|
bothighlight = int(round(1*size))
|
|
|
|
out["sysboxheight"] = height
|
|
|
|
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):
|
|
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, [], out)
|
|
|
|
return canvas
|
|
|
|
def monitor(size):
|
|
canvas = {}
|
|
|
|
# The computer's monitor.
|
|
|
|
height = int(round(9.55*size))
|
|
width = int(round(11.49*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.
|
|
out = {}
|
|
m = monitor(size)
|
|
s = sysbox(size, out)
|
|
x = int(round((2+size/(size+1))*size))
|
|
y = int(out["sysboxheight"] + out["borderthickness"])
|
|
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 height,
|
|
# and an odd number in width.
|
|
width = round(7*size) * 2 - 1
|
|
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 (x,y) in canvas and \
|
|
(x,y-1) in canvas and \
|
|
(x,y+1) in canvas and \
|
|
(x-1,y) in canvas and \
|
|
(x+1,y) in canvas:
|
|
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
|
|
|
|
def box(size, back):
|
|
canvas = {}
|
|
|
|
# The back side of the cardboard box in the installer icon.
|
|
|
|
boxwidth = round(15 * size)
|
|
boxheight = round(12 * size)
|
|
boxdepth = round(4 * size)
|
|
boxfrontflapheight = round(5 * size)
|
|
boxrightflapheight = round(3 * size)
|
|
|
|
# Three shades of basically acceptable brown, all achieved by
|
|
# halftoning between two of the Windows-16 colours. I'm quite
|
|
# pleased that was feasible at all!
|
|
dark = halftone(cr, cK)
|
|
med = halftone(cr, cy)
|
|
light = halftone(cr, cY)
|
|
# We define our halftoning parity in such a way that the black
|
|
# pixels along the RHS of the visible part of the box back
|
|
# match up with the one-pixel black outline around the
|
|
# right-hand side of the box. In other words, we want the pixel
|
|
# at (-1, boxwidth-1) to be black, and hence the one at (0,
|
|
# boxwidth) too.
|
|
parityadjust = int(boxwidth) % 2
|
|
|
|
# The entire back of the box.
|
|
if back:
|
|
for x in range(int(boxwidth + boxdepth)):
|
|
ytop = max(-x-1, -boxdepth-1)
|
|
ybot = min(boxheight, boxheight+boxwidth-1-x)
|
|
for y in range(int(ytop), int(ybot)):
|
|
pixel(x, y, dark[(x+y+parityadjust) % 2], canvas)
|
|
|
|
# Even when drawing the back of the box, we still draw the
|
|
# whole shape, because that means we get the right overall size
|
|
# (the flaps make the box front larger than the box back) and
|
|
# it'll all be overwritten anyway.
|
|
|
|
# The front face of the box.
|
|
for x in range(int(boxwidth)):
|
|
for y in range(int(boxheight)):
|
|
pixel(x, y, med[(x+y+parityadjust) % 2], canvas)
|
|
# The right face of the box.
|
|
for x in range(int(boxwidth), int(boxwidth+boxdepth)):
|
|
ybot = boxheight + boxwidth-x
|
|
ytop = ybot - boxheight
|
|
for y in range(int(ytop), int(ybot)):
|
|
pixel(x, y, dark[(x+y+parityadjust) % 2], canvas)
|
|
# The front flap of the box.
|
|
for y in range(int(boxfrontflapheight)):
|
|
xadj = int(round(-0.5*y))
|
|
for x in range(int(xadj), int(xadj+boxwidth)):
|
|
pixel(x, y, light[(x+y+parityadjust) % 2], canvas)
|
|
# The right flap of the box.
|
|
for x in range(int(boxwidth), int(boxwidth + boxdepth + boxrightflapheight + 1)):
|
|
ytop = max(boxwidth - 1 - x, x - boxwidth - 2*boxdepth - 1)
|
|
ybot = min(x - boxwidth - 1, boxwidth + 2*boxrightflapheight - 1 - x)
|
|
for y in range(int(ytop), int(ybot+1)):
|
|
pixel(x, y, med[(x+y+parityadjust) % 2], canvas)
|
|
|
|
# And draw a border.
|
|
border(canvas, size, [(0, int(boxheight)-1, BL)])
|
|
|
|
return canvas
|
|
|
|
def boxback(size):
|
|
return box(size, 1)
|
|
def boxfront(size):
|
|
return box(size, 0)
|
|
|
|
# Functions to draw entire icons by composing the above components.
|
|
|
|
def xybolt(c1, c2, size, boltoffx=0, boltoffy=0, aux={}):
|
|
# 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)
|
|
aux["c2pos"] = (w-bb[2], 0-bb[1])
|
|
# 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)
|
|
aux["c1pos"] = (0-bb[0], h-bb[3])
|
|
# 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(boltoffx*size), \
|
|
(h-bb[1]-bb[3])/2 + round((boltoffy-2)*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)
|
|
|
|
def puttyins_icon(size):
|
|
aret = {}
|
|
# The box back goes behind the lightning bolt.
|
|
canvas = xybolt(boxback(size), computer(size), size, boltoffx=-2, boltoffy=+1, aux=aret)
|
|
# But the box front goes over the top, so that the lightning
|
|
# bolt appears to come _out_ of the box. Here it's useful to
|
|
# know the exact coordinates where xybolt placed the box back,
|
|
# so we can overlay the box front exactly on top of it.
|
|
c1x, c1y = aret["c1pos"]
|
|
overlay(boxfront(size), c1x, c1y, canvas)
|
|
return canvas
|
|
|
|
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.2)
|
|
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 hx in hty
|
|
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))
|
|
with open(fname, "wb") as f:
|
|
f.write((("P7\nWIDTH %d\nHEIGHT %d\nDEPTH 3\nMAXVAL 255\n" +
|
|
"TUPLTYPE RGB\nENDHDR\n") % (wid, ht)).encode('ASCII'))
|
|
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))
|
|
f.write(bytes(bytearray([r, g, b])))
|
|
|
|
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)
|
|
with open(fname, "wb") as f:
|
|
f.write((("P7\nWIDTH %d\nHEIGHT %d\nDEPTH 4\nMAXVAL 255\n" +
|
|
"TUPLTYPE RGB_ALPHA\nENDHDR\n") %
|
|
(width, width)).encode('ASCII'))
|
|
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
|
|
f.write(bytes(bytearray([r, g, b, a])))
|
|
|
|
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
|
|
def halftone(col1, col2):
|
|
return (col1, col2)
|
|
elif colours == 1:
|
|
# Windows 16-colour palette.
|
|
cK,cr,cg,cy,cb,cm,cc,cP,cw,cR,cG,cY,cB,cM,cC,cW = list(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
|
|
def halftone(col1, col2):
|
|
return (col1, col2)
|
|
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
|
|
def halftone(col1, col2):
|
|
r1,g1,b1,a1 = col1
|
|
r2,g2,b2,a2 = col2
|
|
colret = (int(r1+r2)//2, int(g1+g2)//2, int(b1+b2)//2, int(a1+a2)//2)
|
|
return (colret, colret)
|
|
|
|
if test:
|
|
testrun(eval(realargs[0]), realargs[1])
|
|
else:
|
|
drawicon(eval(realargs[0]), int(realargs[1]), realargs[2], orangebackground)
|