path: root/icons/mksvg.py

#!/usr/bin/env python3

import argparse
import itertools
import math
import os
import sys
from fractions import Fraction

import xml.etree.cElementTree as ET

# Python code which draws the PuTTY icon components in SVG.

def makegroup(*objects):
    if len(objects) == 1:
        return objects[0]
    g = ET.Element("g")
    for obj in objects:
        g.append(obj)
    return g

class Container:
    "Empty class for keeping things in."
    pass

class SVGthing(object):
    def __init__(self):
        self.fillc = "none"
        self.strokec = "none"
        self.strokewidth = 0
        self.strokebehind = False
        self.clipobj = None
        self.props = Container()
    def fmt_colour(self, rgb):
        return "#{0:02x}{1:02x}{2:02x}".format(*rgb)
    def fill(self, colour):
        self.fillc = self.fmt_colour(colour)
    def stroke(self, colour, width=1, behind=False):
        self.strokec = self.fmt_colour(colour)
        self.strokewidth = width
        self.strokebehind = behind
    def clip(self, obj):
        self.clipobj = obj
    def styles(self, elt, styles):
        elt.attrib["style"] = ";".join("{}:{}".format(k,v)
                                       for k,v in sorted(styles.items()))
    def add_clip_paths(self, container, idents, X, Y):
        if self.clipobj:
            self.clipobj.identifier = next(idents)
            clipelt = self.clipobj.render_thing(X, Y)
            clippath = ET.Element("clipPath")
            clippath.attrib["id"] = self.clipobj.identifier
            clippath.append(clipelt)
            container.append(clippath)
            return True
        return False
    def render(self, X, Y, with_styles=True):
        elt = self.render_thing(X, Y)
        if self.clipobj:
            elt.attrib["clip-path"] = "url(#{})".format(
                self.clipobj.identifier)
        estyles = {"fill": self.fillc}
        sstyles = {"stroke": self.strokec}
        if self.strokewidth:
            sstyles["stroke-width"] = "{:g}".format(self.strokewidth)
            sstyles["stroke-linecap"] = "round"
            sstyles["stroke-linejoin"] = "round"
        if not self.strokebehind:
            estyles.update(sstyles)
        if with_styles:
            self.styles(elt, estyles)
        if not self.strokebehind:
            return elt
        selt = self.render_thing(X, Y)
        if with_styles:
            self.styles(selt, sstyles)
        return makegroup(selt, elt)
    def bbox(self):
        it = self.bb_iter()
        xmin, ymin = xmax, ymax = next(it)
        for x, y in it:
            xmin = min(x, xmin)
            xmax = max(x, xmax)
            ymin = min(y, ymin)
            ymax = max(y, ymax)
        r = self.strokewidth / 2.0
        xmin -= r
        ymin -= r
        xmax += r
        ymax += r
        if self.clipobj:
            x0, y0, x1, y1 = self.clipobj.bbox()
            xmin = max(x0, xmin)
            xmax = min(x1, xmax)
            ymin = max(y0, ymin)
            ymax = min(y1, ymax)
        return xmin, ymin, xmax, ymax

class SVGpath(SVGthing):
    def __init__(self, pointlists, closed=True):
        super().__init__()
        self.pointlists = pointlists
        self.closed = closed
    def bb_iter(self):
        for points in self.pointlists:
            for x,y,on in points:
                yield x,y
    def render_thing(self, X, Y):
        pathcmds = []

        for points in self.pointlists:
            while not points[-1][2]:
                points = points[1:] + [points[0]]

            piter = iter(points)

            if self.closed:
                xp, yp, _ = points[-1]
                pathcmds.extend(["M", X+xp, Y-yp])
            else:
                xp, yp, on = next(piter)
                assert on, "Open paths must start with an on-curve point"
                pathcmds.extend(["M", X+xp, Y-yp])

            for x, y, on in piter:
                if isinstance(on, type(())):
                    assert on[0] == "arc"
                    _, rx, ry, rotation, large, sweep = on
                    pathcmds.extend(["a",
                                     rx, ry, rotation,
                                     1 if large else 0,
                                     1 if sweep else 0,
                                     x-xp, -(y-yp)])
                elif not on:
                    x0, y0 = x, y
                    x1, y1, on = next(piter)
                    assert not on
                    x, y, on = next(piter)
                    assert on
                    pathcmds.extend(["c", x0-xp, -(y0-yp),
                                     ",", x1-xp, -(y1-yp),
                                     ",", x-xp, -(y-yp)])
                elif x == xp:
                    pathcmds.extend(["v", -(y-yp)])
                elif x == xp:
                    pathcmds.extend(["h", x-xp])
                else:
                    pathcmds.extend(["l", x-xp, -(y-yp)])

                xp, yp = x, y

            if self.closed:
                pathcmds.append("z")

        path = ET.Element("path")
        path.attrib["d"] = " ".join(str(cmd) for cmd in pathcmds)
        return path

class SVGrect(SVGthing):
    def __init__(self, x0, y0, x1, y1):
        super().__init__()
        self.points = x0, y0, x1, y1
    def bb_iter(self):
        x0, y0, x1, y1 = self.points
        return iter([(x0,y0), (x1,y1)])
    def render_thing(self, X, Y):
        x0, y0, x1, y1 = self.points
        rect = ET.Element("rect")
        rect.attrib["x"] = "{:g}".format(min(X+x0,X+x1))
        rect.attrib["y"] = "{:g}".format(min(Y-y0,Y-y1))
        rect.attrib["width"] = "{:g}".format(abs(x0-x1))
        rect.attrib["height"] = "{:g}".format(abs(y0-y1))
        return rect

class SVGpoly(SVGthing):
    def __init__(self, points):
        super().__init__()
        self.points = points
    def bb_iter(self):
        return iter(self.points)
    def render_thing(self, X, Y):
        poly = ET.Element("polygon")
        poly.attrib["points"] = " ".join("{:g},{:g}".format(X+x,Y-y)
                                         for x,y in self.points)
        return poly

class SVGgroup(object):
    def __init__(self, objects, translations=[]):
        translations = translations + (
            [(0,0)] * (len(objects)-len(translations)))
        self.contents = list(zip(objects, translations))
        self.props = Container()
    def render(self, X, Y):
        return makegroup(*[obj.render(X+x, Y-y) 
                           for obj, (x,y) in self.contents])
    def add_clip_paths(self, container, idents, X, Y):
        toret = False
        for obj, (x,y) in self.contents:
            if obj.add_clip_paths(container, idents, X+x, Y-y):
                toret = True
        return toret
    def bbox(self):
        it = ((x,y) + obj.bbox() for obj, (x,y) in self.contents)
        x, y, xmin, ymin, xmax, ymax = next(it)
        xmin = x+xmin
        ymin = y+ymin
        xmax = x+xmax
        ymax = y+ymax
        for x, y, x0, y0, x1, y1 in it:
            xmin = min(x+x0, xmin)
            xmax = max(x+x1, xmax)
            ymin = min(y+y0, ymin)
            ymax = max(y+y1, ymax)
        return (xmin, ymin, xmax, ymax)

class SVGtranslate(object):
    def __init__(self, obj, translation):
        self.obj = obj
        self.tx, self.ty = translation
    def render(self, X, Y):
        return self.obj.render(X+self.tx, Y+self.ty)
    def add_clip_paths(self, container, idents, X, Y):
        return self.obj.add_clip_paths(container, idents, X+self.tx, Y-self.ty)
    def bbox(self):
        xmin, ymin, xmax, ymax = self.obj.bbox()
        return xmin+self.tx, ymin+self.ty, xmax+self.tx, ymax+self.ty

# Code to actually draw pieces of icon. These don't generally worry
# about positioning within a rectangle; they just draw at a standard
# location, return some useful coordinates, and leave composition
# to other pieces of code.

def sysbox(size):
    # The system box of the computer.

    height = 3.6*size
    width = 16.51*size
    depth = 2*size
    highlight = 1*size

    floppystart = 19*size # measured in half-pixels
    floppyend = 29*size # measured in half-pixels
    floppybottom = highlight
    floppyrheight = 0.7 * size
    floppyheight = floppyrheight
    if floppyheight < 1:
        floppyheight = 1
    floppytop = floppybottom + floppyheight

    background_coords = [
        (0,0), (width,0), (width+depth,depth),
        (width+depth,height+depth), (depth,height+depth), (0,height)]
    background = SVGpoly(background_coords)
    background.fill(greypix(0.75))

    hl_dark = SVGpoly([
        (highlight,0), (highlight,highlight), (width-highlight,highlight),
        (width-highlight,height-highlight), (width+depth,height+depth),
        (width+depth,depth), (width,0)])
    hl_dark.fill(greypix(0.5))

    hl_light = SVGpoly([
        (0,highlight), (highlight,highlight), (highlight,height-highlight),
        (width-highlight,height-highlight), (width+depth,height+depth),
        (width+depth-highlight,height+depth), (width-highlight,height),
        (0,height)])
    hl_light.fill(cW)

    floppy = SVGrect(floppystart/2.0, floppybottom,
                     floppyend/2.0, floppytop)
    floppy.fill(cK)

    outline = SVGpoly(background_coords)
    outline.stroke(cK, width=0.5)

    toret = SVGgroup([background, hl_dark, hl_light, floppy, outline])
    toret.props.sysboxheight = height
    toret.props.borderthickness = 1 # FIXME
    return toret

def monitor(size):
    # The computer's monitor.

    height = 9.5*size
    width = 11.5*size
    surround = 1*size
    botsurround = 2*size
    sheight = height - surround - botsurround
    swidth = width - 2*surround
    depth = 2*size
    highlight = surround/2
    shadow = 0.5*size

    background_coords = [
        (0,0), (width,0), (width+depth,depth),
        (width+depth,height+depth), (depth,height+depth), (0,height)]
    background = SVGpoly(background_coords)
    background.fill(greypix(0.75))

    hl0_dark = SVGpoly([
        (0,0), (highlight,highlight), (width-highlight,highlight),
        (width-highlight,height-highlight), (width+depth,height+depth),
        (width+depth,depth), (width,0)])
    hl0_dark.fill(greypix(0.5))

    hl0_light = SVGpoly([
        (0,0), (highlight,highlight), (highlight,height-highlight),
        (width-highlight,height-highlight), (width,height), (0,height)])
    hl0_light.fill(greypix(1))

    hl1_dark = SVGpoly([
        (surround-highlight,botsurround-highlight), (surround,botsurround),
        (surround,height-surround), (width-surround,height-surround),
        (width-surround+highlight,height-surround+highlight),
        (surround-highlight,height-surround+highlight)])
    hl1_dark.fill(greypix(0.5))

    hl1_light = SVGpoly([
        (surround-highlight,botsurround-highlight), (surround,botsurround),
        (width-surround,botsurround), (width-surround,height-surround),
        (width-surround+highlight,height-surround+highlight),
        (width-surround+highlight,botsurround-highlight)])
    hl1_light.fill(greypix(1))

    screen = SVGrect(surround, botsurround, width-surround, height-surround)
    screen.fill(bluepix(1))

    screenshadow = SVGpoly([
        (surround,botsurround), (surround+shadow,botsurround),
        (surround+shadow,height-surround-shadow),
        (width-surround,height-surround-shadow), 
        (width-surround,height-surround), (surround,height-surround)])
    screenshadow.fill(bluepix(0.5))

    outline = SVGpoly(background_coords)
    outline.stroke(cK, width=0.5)

    toret = SVGgroup([background, hl0_dark, hl0_light, hl1_dark, hl1_light,
                      screen, screenshadow, outline])
    # Give the centre of the screen (for lightning-bolt positioning purposes)
    # as the centre of the _light_ area of the screen, not counting the
    # shadow on the top and left. I think that looks very slightly nicer.
    sbb = (surround+shadow, botsurround, width-surround, height-surround-shadow)
    toret.props.screencentre = ((sbb[0]+sbb[2])/2, (sbb[1]+sbb[3])/2)
    return toret

def computer(size):
    # Monitor plus sysbox.
    m = monitor(size)
    s = sysbox(size)
    x = (2+size/(size+1))*size
    y = int(s.props.sysboxheight + s.props.borderthickness)
    mb = m.bbox()
    sb = s.bbox()
    xoff = mb[0] - sb[0] + x
    yoff = mb[1] - sb[1] + y
    toret = SVGgroup([s, m], [(0,0), (xoff,yoff)])
    toret.props.screencentre = (m.props.screencentre[0]+xoff,
                                m.props.screencentre[1]+yoff)
    return toret

def lightning(size):
    # The lightning bolt motif.

    # Compute the right size of a lightning bolt to exactly connect
    # the centres of the two screens in the main PuTTY icon. We'll use
    # that size of bolt for all the other icons too, for consistency.
    iconw = iconh = 32 * size
    cbb = computer(size).bbox()
    assert cbb[2]-cbb[0] <= iconw and cbb[3]-cbb[1] <= iconh
    width, height = iconw-(cbb[2]-cbb[0]), iconh-(cbb[3]-cbb[1])

    degree = math.pi/180

    centrethickness = 2*size # top-to-bottom thickness of centre bar
    innerangle = 46 * degree # slope of the inner slanting line
    outerangle = 39 * degree # slope of the outer one

    innery = (height - centrethickness) / 2
    outery = (height + centrethickness) / 2
    innerx = innery / math.tan(innerangle)
    outerx = outery / math.tan(outerangle)

    points = [(innerx, innery), (0,0), (outerx, outery)]
    points.extend([(width-x, height-y) for x,y in points])

    # Fill and stroke the lightning bolt.
    #
    # Most of the filled-and-stroked objects in these icons are filled
    # first, and then stroked with width 0.5, so that the edge of the
    # filled area runs down the centre line of the stroke. Put another
    # way, half the stroke covers what would have been the filled
    # area, and the other half covers the background. This seems like
    # the normal way to fill-and-stroke a shape of a given size, and
    # SVG makes it easy by allowing us to specify the polygon just
    # once with both 'fill' and 'stroke' CSS properties.
    #
    # But if we did that in this case, then the tips of the lightning
    # bolt wouldn't have lightning-colour anywhere near them, because
    # the two edges are so close together in angle that the point
    # where the strokes would first _not_ overlap would be miles away
    # from the logical endpoint.
    #
    # So, for this one case, we stroke the polygon first at double the
    # width, and then fill it on top of that, requiring two copies of
    # it in the SVG (though my construction class here hides that
    # detail). The effect is that we still get a stroke of visible
    # width 0.5, but it's entirely outside the filled area of the
    # polygon, so the tips of the yellow interior of the lightning
    # bolt are exactly at the logical endpoints.
    poly = SVGpoly(points)
    poly.fill(cY)
    poly.stroke(cK, width=1, behind=True)
    poly.props.end1 = (0,0)
    poly.props.end2 = (width,height)
    return poly

def document(size):
    # The document used in the PSCP/PSFTP icon.

    width = 13*size
    height = 16*size

    lineht = 0.875*size
    linespc = 1.125*size
    nlines = int((height-linespc)/(lineht+linespc))
    height = nlines*(lineht+linespc)+linespc # round this so it fits better

    paper = SVGrect(0, 0, width, height)
    paper.fill(cW)
    paper.stroke(cK, width=0.5)

    objs = [paper]

    # Now draw lines of text.
    for line in range(nlines):
        # Decide where this line of text begins.
        if line == 0:
            start = 4*size
        elif line < 5*nlines/7:
            start = (line * 4/5) * size
        else:
            start = 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 = end * size

        liney = (lineht+linespc) * (line+1)
        line = SVGrect(start, liney-lineht, end, liney)
        line.fill(cK)
        objs.append(line)

    return SVGgroup(objs)

def hat(size):
    # The secret-agent hat in the Pageant icon.

    leftend = (0, -6*size)
    rightend = (28*size, -12*size)
    dx = rightend[0]-leftend[0]
    dy = rightend[1]-leftend[1]
    tcentre = (leftend[0] + 0.5*dx - 0.3*dy, leftend[1] + 0.5*dy + 0.3*dx)

    hatpoints = [leftend + (True,),
                 (7.5*size, -6*size, True),
                 (12*size, 0, True),
                 (14*size, 3*size, False),
                 (tcentre[0] - 0.1*dx, tcentre[1] - 0.1*dy, False),
                 tcentre + (True,)]
    for x, y, on in list(reversed(hatpoints))[1:]:
        vx, vy = x-tcentre[0], y-tcentre[1]
        coeff = float(vx*dx + vy*dy) / float(dx*dx + dy*dy)
        rx, ry = x - 2*coeff*dx, y - 2*coeff*dy
        hatpoints.append((rx, ry, on))

    mainhat = SVGpath([hatpoints])
    mainhat.fill(cK)

    band = SVGpoly([
        (leftend[0] - 0.1*dy, leftend[1] + 0.1*dx),
        (rightend[0] - 0.1*dy, rightend[1] + 0.1*dx),
        (rightend[0] - 0.15*dy, rightend[1] + 0.15*dx),
        (leftend[0] - 0.15*dy, leftend[1] + 0.15*dx)])
    band.fill(cW)
    band.clip(SVGpath([hatpoints]))

    outline = SVGpath([hatpoints])
    outline.stroke(cK, width=1)

    return SVGgroup([mainhat, band, outline])

def key(size):
    # The key in the PuTTYgen icon.

    keyheadw = 9.5*size
    keyheadh = 12*size
    keyholed = 4*size
    keyholeoff = 2*size
    # Ensure keyheadh and keyshafth have the same parity.
    keyshafth = (2*size - (int(keyheadh)&1)) / 2 * 2 + (int(keyheadh)&1)
    keyshaftw = 18.5*size
    keyheaddetail = [x*size for x in [12,11,8,10,9,8,11,12]]

    squarepix = []

    keyheadcx = keyshaftw + keyheadw / 2.0
    keyheadcy = keyheadh / 2.0
    keyshafttop = keyheadcy + keyshafth / 2.0
    keyshaftbot = keyheadcy - keyshafth / 2.0

    keyhead = [(0, keyshafttop, True), (keyshaftw, keyshafttop, True),
               (keyshaftw, keyshaftbot,
                ("arc", keyheadw/2.0, keyheadh/2.0, 0, True, True)),
               (len(keyheaddetail)*size, keyshaftbot, True)]
    for i, h in reversed(list(enumerate(keyheaddetail))):
        keyhead.append(((i+1)*size, keyheadh-h, True))
        keyhead.append(((i)*size, keyheadh-h, True))

    keyholecx = keyheadcx + keyholeoff
    keyholecy = keyheadcy
    keyholer = keyholed / 2.0

    keyhole = [(keyholecx + keyholer, keyholecy,
                ("arc", keyholer, keyholer, 0, False, False)),
               (keyholecx - keyholer, keyholecy,
                ("arc", keyholer, keyholer, 0, False, False))]

    outline = SVGpath([keyhead, keyhole])
    outline.fill(cy)
    outline.stroke(cK, width=0.5)
    return outline

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):
    # The spanner in the config box icon.

    # Coordinate definitions.
    headcentre = 0.5 + 4*size
    headradius = headcentre + 0.1
    headhighlight = 1.5*size
    holecentre = 0.5 + 3*size
    holeradius = 2*size
    holehighlight = 1.5*size
    shaftend = 0.5 + 25*size
    shaftwidth = 2*size
    shafthighlight = 1.5*size
    cmax = shaftend + shaftwidth

    # The spanner head is a circle centred at headcentre*(1,1) with
    # radius headradius, minus a circle at holecentre*(1,1) with
    # radius holeradius, and also minus every translate of that circle
    # by a negative real multiple of (1,1).
    #
    # The spanner handle is a diagonally oriented rectangle, of width
    # shaftwidth, with the centre of the far end at shaftend*(1,1),
    # and the near end terminating somewhere inside the spanner head
    # (doesn't really matter exactly where).
    #
    # Hence, in SVG we can represent the shape using a path of
    # straight lines and circular arcs. But first we need to calculate
    # the points where the straight lines meet the spanner head circle.
    headpt = lambda a, on=True: (headcentre+headradius*math.cos(a),
                                 -headcentre+headradius*math.sin(a), on)
    holept = lambda a, on=True: (holecentre+holeradius*math.cos(a),
                                 -holecentre+holeradius*math.sin(a), on)

    # Now we can specify the path.
    spannercoords = [[
        holept(math.pi*5/4),
        holept(math.pi*1/4, ("arc", holeradius,holeradius,0, False, False)),
        headpt(math.pi*3/4 - math.asin(holeradius/headradius)),
        headpt(math.pi*7/4 + math.asin(shaftwidth/headradius),
               ("arc", headradius,headradius,0, False, True)),
        (shaftend+math.sqrt(0.5)*shaftwidth,
         -shaftend+math.sqrt(0.5)*shaftwidth, True),
        (shaftend-math.sqrt(0.5)*shaftwidth,
         -shaftend-math.sqrt(0.5)*shaftwidth, True),
        headpt(math.pi*7/4 - math.asin(shaftwidth/headradius)),
        headpt(math.pi*3/4 + math.asin(holeradius/headradius),
               ("arc", headradius,headradius,0, False, True)),
    ]]

    base = SVGpath(spannercoords)
    base.fill(cY)

    shadowthickness = 2*size
    sx, sy, _ = holept(math.pi*5/4)
    sx += math.sqrt(0.5) * shadowthickness/2
    sy += math.sqrt(0.5) * shadowthickness/2
    sr = holeradius - shadowthickness/2

    shadow = SVGpath([
        [(sx, sy, sr),
         holept(math.pi*1/4, ("arc", sr, sr, 0, False, False)),
         headpt(math.pi*3/4 - math.asin(holeradius/headradius))],
        [(shaftend-math.sqrt(0.5)*shaftwidth,
          -shaftend-math.sqrt(0.5)*shaftwidth, True),
         headpt(math.pi*7/4 - math.asin(shaftwidth/headradius)),
         headpt(math.pi*3/4 + math.asin(holeradius/headradius),
                ("arc", headradius,headradius,0, False, True))],
    ], closed=False)
    shadow.clip(SVGpath(spannercoords))
    shadow.stroke(cy, width=shadowthickness)

    outline = SVGpath(spannercoords)
    outline.stroke(cK, width=0.5)

    return SVGgroup([base, shadow, outline])

def box(size, wantback):
    # The back side of the cardboard box in the installer icon.

    boxwidth = 15 * size
    boxheight = 12 * size
    boxdepth = 4 * size
    boxfrontflapheight = 5 * size
    boxrightflapheight = 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 back of the box.
    if wantback:
        back = SVGpoly([
            (0,0), (boxwidth,0), (boxwidth+boxdepth,boxdepth),
            (boxwidth+boxdepth,boxheight+boxdepth),
            (boxdepth,boxheight+boxdepth), (0,boxheight)])
        back.fill(dark)
        back.stroke(cK, width=0.5)
        return back

    # The front face of the box.
    front = SVGrect(0, 0, boxwidth, boxheight)
    front.fill(med)
    front.stroke(cK, width=0.5)
    # The right face of the box.
    right = SVGpoly([
        (boxwidth,0), (boxwidth+boxdepth,boxdepth),
        (boxwidth+boxdepth,boxheight+boxdepth), (boxwidth,boxheight)])
    right.fill(dark)
    right.stroke(cK, width=0.5)
    frontflap = SVGpoly([
        (0,boxheight), (boxwidth,boxheight),
        (boxwidth-boxfrontflapheight/2, boxheight-boxfrontflapheight),
        (-boxfrontflapheight/2, boxheight-boxfrontflapheight)])
    frontflap.stroke(cK, width=0.5)
    frontflap.fill(light)
    rightflap = SVGpoly([
        (boxwidth,boxheight), (boxwidth+boxdepth,boxheight+boxdepth),
        (boxwidth+boxdepth+boxrightflapheight,
         boxheight+boxdepth-boxrightflapheight),
        (boxwidth+boxrightflapheight,boxheight-boxrightflapheight)])
    rightflap.stroke(cK, width=0.5)
    rightflap.fill(med)

    return SVGgroup([front, right, frontflap, rightflap])

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, c1bb=None, c2bb=None):
    # Two unspecified objects and a lightning bolt.

    w = h = 32 * size

    bolt = lightning(size)

    objs = [c2, c1, bolt]
    origins = [None] * 3

    # Position c2 against the top right of the icon.
    bb = c2bb if c2bb is not None else c2.bbox()
    assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
    origins[0] = w-bb[2], h-bb[3]
    # Position c1 against the bottom left of the icon.
    bb = c1bb if c1bb is not None else c1.bbox()
    assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
    origins[1] = 0-bb[0], 0-bb[1]

    # Place the lightning bolt so that it ends precisely at the centre
    # of the monitor, in whichever of the two sub-pictures has one.
    # (In the case of the PuTTY icon proper, in which _both_
    # sub-pictures are computers, it should line up correctly for both.)
    origin1 = origin2 = None
    if hasattr(c1.props, "screencentre"):
        origin1 = (
            c1.props.screencentre[0] + origins[1][0] - bolt.props.end1[0],
            c1.props.screencentre[1] + origins[1][1] - bolt.props.end1[1])
    if hasattr(c2.props, "screencentre"):
        origin2 = (
            c2.props.screencentre[0] + origins[0][0] - bolt.props.end2[0],
            c2.props.screencentre[1] + origins[0][1] - bolt.props.end2[1])
    if origin1 is not None and origin2 is not None:
        assert math.hypot(origin1[0]-origin2[0],origin1[1]-origin2[1]<1e-5), (
            "Lightning bolt didn't line up! Off by {}*size".format(
                ((origin1[0]-origin2[0])/size,
                 (origin1[1]-origin2[1])/size)))
    origins[2] = origin1 if origin1 is not None else origin2
    assert origins[2] is not None, "Need at least one computer to line up bolt"

    toret = SVGgroup(objs, origins)
    toret.props.c1pos = origins[1]
    toret.props.c2pos = origins[0]
    return toret

def putty_icon(size):
    return xybolt(computer(size), computer(size), size)

def puttycfg_icon(size):
    w = h = 32 * size
    s = spanner(size)
    b = putty_icon(size)
    bb = s.bbox()
    return SVGgroup([b, s], [(0,0), ((w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2)])

def puttygen_icon(size):
    k = key(size)
    # Manually move the key around, by pretending to xybolt that its
    # bounding box is offset from where it really is.
    kbb = SVGtranslate(k,(2*size,5*size)).bbox()
    return xybolt(computer(size), k, size, boltoffx=2, c2bb=kbb)

def pscp_icon(size):
    return xybolt(document(size), computer(size), size)

def puttyins_icon(size):
    boxfront = box(size, False)
    boxback = box(size, True)
    # The box back goes behind the lightning bolt.
    most = xybolt(boxback, computer(size), size, c1bb=boxfront.bbox(),
                  boltoffx=-2, boltoffy=+1)
    # 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 = most.props.c1pos
    return SVGgroup([most, boxfront], [(0,0), most.props.c1pos])

def pterm_icon(size):
    # Just a really big computer.

    w = h = 32 * size

    c = computer(size * 1.4)

    # Centre c in the output rectangle.
    bb = c.bbox()
    assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h

    return SVGgroup([c], [((w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2)])

def ptermcfg_icon(size):
    w = h = 32 * size
    s = spanner(size)
    b = pterm_icon(size)
    bb = s.bbox()
    return SVGgroup([b, s], [(0,0), ((w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2)])

def pageant_icon(size):
    # A biggish computer, in a hat.

    w = h = 32 * size

    c = computer(size * 1.2)
    ht = hat(size)

    cbb = c.bbox()
    hbb = ht.bbox()

    # Determine the relative coordinates of the computer and hat. We
    # do this by first centring one on the other, then adjusting by
    # hand.
    xrel = (cbb[0]+cbb[2]-hbb[0]-hbb[2])/2 + 2*size
    yrel = (cbb[1]+cbb[3]-hbb[1]-hbb[3])/2 + 12*size

    both = SVGgroup([c, ht], [(0,0), (xrel,yrel)])

    # Mostly-centre the result in the output rectangle. We want
    # everything to fit in frame, but we also want to make it look as
    # if the computer is more x-centred than the hat.

    # Coordinates that would centre the whole group.
    bb = both.bbox()
    assert bb[2]-bb[0] <= w and bb[3]-bb[1] <= h
    grx, gry = (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2

    # Coords that would centre just the computer.
    bb = c.bbox()
    crx, cry = (w-bb[0]-bb[2])/2, (h-bb[1]-bb[3])/2

    # Use gry unchanged, but linear-combine grx with crx.
    return SVGgroup([both], [(grx+0.6*(crx-grx), gry)])

# Test and output functions.

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 halftone(col1, col2):
    r1,g1,b1,a1 = col1
    r2,g2,b2,a2 = col2
    return ((r1+r2)//2, (g1+g2)//2, (b1+b2)//2, (a1+a2)//2)

def drawicon(func, width, fname):
    icon = func(width / 32.0)
    minx, miny, maxx, maxy = icon.bbox()
    #assert minx >= 0 and miny >= 0 and maxx <= width and maxy <= width

    svgroot = ET.Element("svg")
    svgroot.attrib["xmlns"] = "http://www.w3.org/2000/svg"
    svgroot.attrib["viewBox"] = "0 0 {w:d} {w:d}".format(w=width)

    defs = ET.Element("defs")
    idents = ("iconid{:d}".format(n) for n in itertools.count())
    if icon.add_clip_paths(defs, idents, 0, width):
        svgroot.append(defs)

    svgroot.append(icon.render(0,width))

    ET.ElementTree(svgroot).write(fname)

def main():
    parser = argparse.ArgumentParser(description='Generate PuTTY SVG icons.')
    parser.add_argument("icon", help="Which icon to generate.")
    parser.add_argument("-s", "--size", type=int, default=48,
                        help="Notional pixel size to base the SVG on.")
    parser.add_argument("-o", "--output", required=True,
                        help="Output file name.")
    args = parser.parse_args()

    drawicon(eval(args.icon), args.size, args.output)

if __name__ == '__main__':
    main()