stuff

buildfiles/node_modules/dmg-builder/vendor/dmgbuild/badge.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from Quartz import *
+import math
+
+_REMOVABLE_DISK_PATH = '/System/Library/Extensions/IOStorageFamily.kext/Contents/Resources/Removable.icns'
+
+def badge_disk_icon(badge_file, output_file):
+    # Load the Removable disk icon
+    url = CFURLCreateWithFileSystemPath(None, _REMOVABLE_DISK_PATH,
+                                        kCFURLPOSIXPathStyle, False)
+    backdrop = CGImageSourceCreateWithURL(url, None)
+    backdropCount = CGImageSourceGetCount(backdrop)
+    
+    # Load the badge
+    url = CFURLCreateWithFileSystemPath(None, badge_file,
+                                        kCFURLPOSIXPathStyle, False)
+    badge = CGImageSourceCreateWithURL(url, None)
+    assert badge is not None, 'Unable to process image file: %s' % badge_file
+    badgeCount = CGImageSourceGetCount(badge)
+    
+    # Set up a destination for our target
+    url = CFURLCreateWithFileSystemPath(None, output_file,
+                                        kCFURLPOSIXPathStyle, False)
+    target = CGImageDestinationCreateWithURL(url, 'com.apple.icns',
+                                             backdropCount, None)
+
+    # Get the RGB colorspace
+    rgbColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB)
+
+    # Scale
+    scale = 1.0
+    
+    # Perspective transform
+    corners = ((0.2, 0.95), (0.8, 0.95), (0.85, 0.35), (0.15, 0.35))
+
+    # Translation
+    position = (0.5, 0.5)
+
+    for n in range(backdropCount):
+        props = CGImageSourceCopyPropertiesAtIndex(backdrop, n, None)
+        width = props['PixelWidth']
+        height = props['PixelHeight']
+        dpi = props['DPIWidth']
+        depth = props['Depth']
+        
+        # Choose the best sized badge image
+        bestWidth = None
+        bestHeight = None
+        bestBadge = None
+        bestDepth = None
+        bestDPI = None
+        for m in range(badgeCount):
+            badgeProps = CGImageSourceCopyPropertiesAtIndex(badge, m, None)
+            badgeWidth = badgeProps['PixelWidth']
+            badgeHeight = badgeProps['PixelHeight']
+            badgeDPI = badgeProps['DPIWidth']
+            badgeDepth = badgeProps['Depth']
+            
+            if bestBadge is None or (badgeWidth <= width
+                                    and (bestWidth > width
+                                        or badgeWidth > bestWidth
+                                        or (badgeWidth == bestWidth
+                                            and badgeDPI == dpi
+                                            and badgeDepth <= depth
+                                            and (bestDepth is None
+                                                 or badgeDepth > bestDepth)))):
+                bestBadge = m
+                bestWidth = badgeWidth
+                bestHeight = badgeHeight
+                bestDPI = badgeDPI
+                bestDepth = badgeDepth
+
+        badgeImage = CGImageSourceCreateImageAtIndex(badge, bestBadge, None)
+        badgeCI = CIImage.imageWithCGImage_(badgeImage)
+    
+        backgroundImage = CGImageSourceCreateImageAtIndex(backdrop, n, None)
+        backgroundCI = CIImage.imageWithCGImage_(backgroundImage)
+    
+        compositor = CIFilter.filterWithName_('CISourceOverCompositing')
+        lanczos = CIFilter.filterWithName_('CILanczosScaleTransform')
+        perspective = CIFilter.filterWithName_('CIPerspectiveTransform')
+        transform = CIFilter.filterWithName_('CIAffineTransform')
+    
+        lanczos.setValue_forKey_(badgeCI, kCIInputImageKey)
+        lanczos.setValue_forKey_(scale * float(width)/bestWidth, kCIInputScaleKey)
+        lanczos.setValue_forKey_(1.0, kCIInputAspectRatioKey)
+
+        topLeft = (width * scale * corners[0][0],
+                   width * scale * corners[0][1])
+        topRight = (width * scale * corners[1][0],
+                    width * scale * corners[1][1])
+        bottomRight = (width * scale * corners[2][0],
+                       width * scale * corners[2][1])
+        bottomLeft = (width * scale * corners[3][0],
+                      width * scale * corners[3][1])
+
+        out = lanczos.valueForKey_(kCIOutputImageKey)
+        if width >= 16:
+            perspective.setValue_forKey_(out, kCIInputImageKey)
+            perspective.setValue_forKey_(CIVector.vectorWithX_Y_(*topLeft),
+                                         'inputTopLeft')
+            perspective.setValue_forKey_(CIVector.vectorWithX_Y_(*topRight),
+                                         'inputTopRight')
+            perspective.setValue_forKey_(CIVector.vectorWithX_Y_(*bottomRight),
+                                         'inputBottomRight')
+            perspective.setValue_forKey_(CIVector.vectorWithX_Y_(*bottomLeft),
+                                         'inputBottomLeft')
+            out = perspective.valueForKey_(kCIOutputImageKey)
+
+        tfm = NSAffineTransform.transform()
+        tfm.translateXBy_yBy_(math.floor((position[0] - 0.5 * scale) * width),
+                              math.floor((position[1] - 0.5 * scale) * height))
+
+        transform.setValue_forKey_(out, kCIInputImageKey)
+        transform.setValue_forKey_(tfm, 'inputTransform')
+        out = transform.valueForKey_(kCIOutputImageKey)
+    
+        compositor.setValue_forKey_(out, kCIInputImageKey)
+        compositor.setValue_forKey_(backgroundCI, kCIInputBackgroundImageKey)
+
+        result = compositor.valueForKey_(kCIOutputImageKey)
+
+        cgContext = CGBitmapContextCreate(None,
+                                        width,
+                                        height,
+                                        8,
+                                        0,
+                                        rgbColorSpace,
+                                        kCGImageAlphaPremultipliedLast)
+        context = CIContext.contextWithCGContext_options_(cgContext, None)
+
+        context.drawImage_inRect_fromRect_(result,
+                                           ((0, 0), (width, height)),
+                                           ((0, 0), (width, height)))
+
+        image = CGBitmapContextCreateImage(cgContext)
+
+        CGImageDestinationAddImage(target, image, props)
+
+    CGImageDestinationFinalize(target)
+    

buildfiles/node_modules/dmg-builder/vendor/dmgbuild/colors.py

@@ -0,0 +1,494 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import re
+import math
+
+class Color (object):
+    def to_rgb(self):
+        raise Exception('Must implement to_rgb() in subclasses')
+
+class RGB (Color):
+    def __init__(self, r, g, b):
+        self.r = r
+        self.g = g
+        self.b = b
+
+    def to_rgb(self):
+        return self
+    
+class HSL (Color):
+    def __init__(self, h, s, l):
+        self.h = h
+        self.s = s
+        self.l = l
+
+    @staticmethod
+    def _hue_to_rgb(t1, t2, hue):
+        if hue < 0:
+            hue += 6
+        elif hue >= 6:
+            hue -= 6
+
+        if hue < 1:
+            return (t2 - t1) * hue + t1
+        elif hue < 3:
+            return t2
+        elif hue < 4:
+            return (t2 - t1) * (4 - hue) + t1
+        else:
+            return t1
+        
+    def to_rgb(self):
+        hue = self.h / 60.0
+        if self.l <= 0.5:
+            t2 = self.l * (self.s + 1)
+        else:
+            t2 = self.l + self.s - (self.l * self.s)
+        t1 = self.l * 2 - t2
+        r = self._hue_to_rgb(t1, t2, hue + 2)
+        g = self._hue_to_rgb(t1, t2, hue)
+        b = self._hue_to_rgb(t1, t2, hue - 2)
+        return RGB(r, g, b)
+    
+class HWB (Color):
+    def __init__(self, h, w, b):
+        self.h = h
+        self.w = w
+        self.b = b
+
+    @staticmethod
+    def _hue_to_rgb(hue):
+        if hue < 0:
+            hue += 6
+        elif hue >= 6:
+            hue -= 6
+
+        if hue < 1:
+            return hue
+        elif hue < 3:
+            return 1
+        elif hue < 4:
+            return (4 - hue)
+        else:
+            return 0
+ 
+    def to_rgb(self):
+        hue = self.h / 60.0
+        t1 = 1 - self.w - self.b
+        r = self._hue_to_rgb(hue + 2) * t1 + self.w
+        g = self._hue_to_rgb(hue) * t1 + self.w
+        b = self._hue_to_rgb(hue - 2) * t1 + self.w
+        return RGB(r, g, b)
+    
+class CMYK (Color):
+    def __init__(self, c, m, y, k):
+        self.c = c
+        self.m = m
+        self.y = y
+        self.k = k
+
+    def to_rgb(self):
+        r = 1.0 - min(1.0, self.c + self.k)
+        g = 1.0 - min(1.0, self.m + self.k)
+        b = 1.0 - min(1.0, self.y + self.k)
+        return RGB(r, g, b)
+    
+class Gray (Color):
+    def __init__(self, g):
+        self.g = g
+
+    def to_rgb(self):
+        return RGB(g, g, g)
+    
+_x11_colors = {
+	'aliceblue': (240, 248, 255),
+    'antiquewhite': (250, 235, 215),
+    'aqua':	( 0, 255, 255),
+    'aquamarine': (127, 255, 212),
+    'azure': (240, 255, 255),
+    'beige': (245, 245, 220),
+    'bisque': (255, 228, 196),
+    'black': ( 0, 0, 0),
+    'blanchedalmond': (255, 235, 205),
+    'blue': ( 0, 0, 255),
+    'blueviolet': (138, 43, 226),
+    'brown': (165, 42, 42),
+    'burlywood': (222, 184, 135),
+    'cadetblue': ( 95, 158, 160),
+    'chartreuse': (127, 255, 0),
+    'chocolate': (210, 105, 30),
+    'coral': (255, 127, 80),
+    'cornflowerblue': (100, 149, 237),
+    'cornsilk': (255, 248, 220),
+    'crimson': (220, 20, 60),
+    'cyan': ( 0, 255, 255),
+    'darkblue': ( 0, 0, 139),
+    'darkcyan': ( 0, 139, 139),
+    'darkgoldenrod': (184, 134, 11),
+    'darkgray': (169, 169, 169),
+    'darkgreen': ( 0, 100, 0),
+    'darkgrey': (169, 169, 169),
+    'darkkhaki': (189, 183, 107),
+    'darkmagenta': (139, 0, 139),
+    'darkolivegreen': ( 85, 107, 47),
+    'darkorange': (255, 140, 0),
+    'darkorchid': (153, 50, 204),
+    'darkred': (139, 0, 0),
+    'darksalmon': (233, 150, 122),
+    'darkseagreen': (143, 188, 143),
+    'darkslateblue': ( 72, 61, 139),
+    'darkslategray': ( 47, 79, 79),
+    'darkslategrey': ( 47, 79, 79),
+    'darkturquoise': ( 0, 206, 209),
+    'darkviolet': (148, 0, 211),
+    'deeppink': (255, 20, 147),
+    'deepskyblue': ( 0, 191, 255),
+    'dimgray': (105, 105, 105),
+    'dimgrey': (105, 105, 105),
+    'dodgerblue': ( 30, 144, 255),
+    'firebrick': (178, 34, 34),
+    'floralwhite': (255, 250, 240),
+    'forestgreen': ( 34, 139, 34),
+    'fuchsia': (255, 0, 255),
+    'gainsboro': (220, 220, 220),
+    'ghostwhite': (248, 248, 255),
+    'gold': (255, 215, 0),
+    'goldenrod': (218, 165, 32),
+    'gray': (128, 128, 128),
+    'grey': (128, 128, 128),
+    'green': ( 0, 128, 0),
+    'greenyellow': (173, 255, 47),
+    'honeydew': (240, 255, 240),
+    'hotpink': (255, 105, 180),
+    'indianred': (205, 92, 92),
+    'indigo': ( 75, 0, 130),
+    'ivory': (255, 255, 240),
+    'khaki': (240, 230, 140),
+    'lavender': (230, 230, 250),
+    'lavenderblush': (255, 240, 245),
+    'lawngreen': (124, 252, 0),
+    'lemonchiffon': (255, 250, 205),
+    'lightblue': (173, 216, 230),
+    'lightcoral': (240, 128, 128),
+    'lightcyan': (224, 255, 255),
+    'lightgoldenrodyellow': (250, 250, 210),
+    'lightgray': (211, 211, 211),
+    'lightgreen': (144, 238, 144),
+    'lightgrey': (211, 211, 211),
+    'lightpink': (255, 182, 193),
+    'lightsalmon': (255, 160, 122),
+    'lightseagreen': ( 32, 178, 170),
+    'lightskyblue': (135, 206, 250),
+    'lightslategray': (119, 136, 153),
+    'lightslategrey': (119, 136, 153),
+    'lightsteelblue': (176, 196, 222),
+    'lightyellow': (255, 255, 224),
+    'lime': ( 0, 255, 0),
+    'limegreen': ( 50, 205, 50),
+    'linen': (250, 240, 230),
+    'magenta': (255, 0, 255),
+    'maroon': (128, 0, 0),
+    'mediumaquamarine': (102, 205, 170),
+    'mediumblue': ( 0, 0, 205),
+    'mediumorchid': (186, 85, 211),
+    'mediumpurple': (147, 112, 219),
+    'mediumseagreen': ( 60, 179, 113),
+    'mediumslateblue': (123, 104, 238),
+    'mediumspringgreen': ( 0, 250, 154),
+    'mediumturquoise': ( 72, 209, 204),
+    'mediumvioletred': (199, 21, 133),
+    'midnightblue': ( 25, 25, 112),
+    'mintcream': (245, 255, 250),
+    'mistyrose': (255, 228, 225),
+    'moccasin': (255, 228, 181),
+    'navajowhite': (255, 222, 173),
+    'navy': ( 0, 0, 128),
+    'oldlace': (253, 245, 230),
+    'olive': (128, 128, 0),
+    'olivedrab': (107, 142, 35),
+    'orange': (255, 165, 0),
+    'orangered': (255, 69, 0),
+    'orchid': (218, 112, 214),
+    'palegoldenrod': (238, 232, 170),
+    'palegreen': (152, 251, 152),
+    'paleturquoise': (175, 238, 238),
+    'palevioletred': (219, 112, 147),
+    'papayawhip': (255, 239, 213),
+    'peachpuff': (255, 218, 185),
+    'peru': (205, 133, 63),
+    'pink': (255, 192, 203),
+    'plum': (221, 160, 221),
+    'powderblue': (176, 224, 230),
+    'purple': (128, 0, 128),
+    'red': (255, 0, 0),
+    'rosybrown': (188, 143, 143),
+    'royalblue': ( 65, 105, 225),
+    'saddlebrown': (139, 69, 19),
+    'salmon': (250, 128, 114),
+    'sandybrown': (244, 164, 96),
+    'seagreen': ( 46, 139, 87),
+    'seashell': (255, 245, 238),
+    'sienna': (160, 82, 45),
+    'silver': (192, 192, 192),
+    'skyblue': (135, 206, 235),
+    'slateblue': (106, 90, 205),
+    'slategray': (112, 128, 144),
+    'slategrey': (112, 128, 144),
+    'snow': (255, 250, 250),
+    'springgreen': ( 0, 255, 127),
+    'steelblue': ( 70, 130, 180),
+    'tan': (210, 180, 140),
+    'teal': ( 0, 128, 128),
+    'thistle': (216, 191, 216),
+    'tomato': (255, 99, 71),
+    'turquoise': ( 64, 224, 208),
+    'violet': (238, 130, 238),
+    'wheat': (245, 222, 179),
+    'white': (255, 255, 255),
+    'whitesmoke': (245, 245, 245),
+    'yellow': (255, 255, 0),
+    'yellowgreen': (154, 205, 50)
+    }
+    
+_ws_re = re.compile('\s+')
+_token_re = re.compile('[A-Za-z_][A-Za-z0-9_]*')
+_hex_re = re.compile('#([0-9a-f]{3}(?:[0-9a-f]{3})?)$')
+_number_re = re.compile('[0-9]*(\.[0-9]*)')
+
+class ColorParser (object):
+    def __init__(self, s):
+        self._string = s
+        self._pos = 0
+
+    def skipws(self):
+        m = _ws_re.match(self._string, self._pos)
+        if m:
+            self._pos = m.end(0)
+        
+    def expect(self, s, context=''):
+        if len(self._string) - self._pos < len(s) \
+          or self._string[self._pos:self._pos + len(s)] != s:
+            raise ValueError('bad color "%s" - expected "%s"%s'
+                            % (self._string, s, context))
+        self._pos += len(s)
+
+    def expectEnd(self):
+        if self._pos != len(self._string):
+            raise ValueError('junk at end of color "%s"' % self._string)
+
+    def getToken(self):
+        m = _token_re.match(self._string, self._pos)
+        if m:
+            token = m.group(0)
+
+            self._pos = m.end(0)
+            return token
+        return None
+        
+    def parseNumber(self, context=''):
+        m = _number_re.match(self._string, self._pos)
+        if m:
+            self._pos = m.end(0)
+            return float(m.group(0))
+        raise ValueError('bad color "%s" - expected a number%s'
+                         % (self._string, context))
+    
+    def parseColor(self):
+        self.skipws()
+
+        token = self.getToken()
+        if token:
+            if token == 'rgb':
+                return self.parseRGB()
+            elif token == 'hsl':
+                return self.parseHSL()
+            elif token == 'hwb':
+                return self.parseHWB()
+            elif token == 'cmyk':
+                return self.parseCMYK()
+            elif token == 'gray' or token == 'grey':
+                return self.parseGray()
+
+            try:
+                r, g, b = _x11_colors[token]
+            except KeyError:
+                raise ValueError('unknown color name "%s"' % token)
+
+            self.expectEnd()
+
+            return RGB(r / 255.0, g / 255.0, b / 255.0)
+        
+        m = _hex_re.match(self._string, self._pos)
+        if m:
+            hrgb = m.group(1)
+
+            if len(hrgb) == 3:
+                r = int('0x' + 2 * hrgb[0], 16)
+                g = int('0x' + 2 * hrgb[1], 16)
+                b = int('0x' + 2 * hrgb[2], 16)
+            else:
+                r = int('0x' + hrgb[0:2], 16)
+                g = int('0x' + hrgb[2:4], 16)
+                b = int('0x' + hrgb[4:6], 16)
+
+            self._pos = m.end(0)
+            self.skipws()
+
+            self.expectEnd()
+
+            return RGB(r / 255.0, g / 255.0, b / 255.0)
+
+        raise ValueError('bad color syntax "%s"' % self._string)
+
+    def parseRGB(self):
+        self.expect('(', 'after "rgb"')
+        self.skipws()
+
+        r = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "rgb"')
+        self.skipws()
+
+        g = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "rgb"')
+        self.skipws()
+
+        b = self.parseValue()
+
+        self.skipws()
+        self.expect(')', 'at end of "rgb"')
+
+        self.skipws()
+        self.expectEnd()
+
+        return RGB(r, g, b)
+        
+    def parseHSL(self):
+        self.expect('(', 'after "hsl"')
+        self.skipws()
+
+        h = self.parseAngle()
+
+        self.skipws()
+        self.expect(',', 'in "hsl"')
+        self.skipws()
+
+        s = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "hsl"')
+        self.skipws()
+
+        l = self.parseValue()
+
+        self.skipws()
+        self.expect(')', 'at end of "hsl"')
+
+        self.skipws()
+        self.expectEnd()
+
+        return HSL(h, s, l)
+
+    def parseHWB(self):
+        self.expect('(', 'after "hwb"')
+        self.skipws()
+
+        h = self.parseAngle()
+
+        self.skipws()
+        self.expect(',', 'in "hwb"')
+        self.skipws()
+
+        w = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "hwb"')
+        self.skipws()
+
+        b = self.parseValue()
+
+        self.skipws()
+        self.expect(')', 'at end of "hwb"')
+
+        self.skipws()
+        self.expectEnd()
+
+        return HWB(h, w, b)
+
+    def parseCMYK(self):
+        self.expect('(', 'after "cmyk"')
+        self.skipws()
+
+        c = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "cmyk"')
+        self.skipws()
+
+        m = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "cmyk"')
+        self.skipws()
+
+        y = self.parseValue()
+
+        self.skipws()
+        self.expect(',', 'in "cmyk"')
+        self.skipws()
+
+        k = self.parseValue()
+
+        self.skipws()
+        self.expect(')', 'at end of "cmyk"')
+
+        self.skipws()
+        self.expectEnd()
+
+        return CMYK(c, m, y, k)
+
+    def parseGray(self):
+        self.expect('(', 'after "gray"')
+        self.skipws()
+
+        g = self.parseValue()
+
+        self.skipws()
+        self.expect(')', 'at end of "gray')
+
+        self.skipws()
+        self.expectEnd()
+
+        return Gray(g)
+
+    def parseValue(self):
+        n = self.parseNumber()
+        self.skipws()
+        if self._string[self._pos] == '%':
+            n = n / 100.0
+            self.pos += 1
+        return n
+    
+    def parseAngle(self):
+        n = self.parseNumber()
+        self.skipws()
+        tok = self.getToken()
+        if tok == 'rad':
+            n = n * 180.0 / math.pi
+        elif tok == 'grad' or tok == 'gon':
+            n = n * 0.9
+        elif tok != 'deg':
+            raise ValueError('bad angle unit "%s"' % tok)
+        return n
+
+_color_re = re.compile('\s*(#|rgb|hsl|hwb|cmyk|gray|grey|%s)'
+                       % '|'.join(_x11_colors.keys()))
+def isAColor(s):
+    return _color_re.match(s)
+
+def parseColor(s):
+    return ColorParser(s).parseColor()

buildfiles/node_modules/dmg-builder/vendor/dmgbuild/core.py

@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+import os
+import re
+import sys
+reload(sys)  # Reload is a hack
+sys.setdefaultencoding('UTF8')
+
+sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), "..")))
+
+try:
+  {}.iteritems
+  iteritems = lambda x: x.iteritems()
+  iterkeys = lambda x: x.iterkeys()
+except AttributeError:
+  iteritems = lambda x: x.items()
+  iterkeys = lambda x: x.keys()
+try:
+  unicode
+except NameError:
+  unicode = str
+
+import biplist
+from mac_alias import *
+from ds_store import *
+
+from colors import parseColor
+
+try:
+  from badge import badge
+except ImportError:
+  badge = None
+
+class DMGError(Exception):
+  pass
+
+
+def build_dmg():
+  options = {
+    'icon': None,
+    'badge_icon': None,
+    'sidebar_width': 180,
+    'arrange_by': None,
+    'grid_offset': (0, 0),
+    'grid_spacing': 100.0,
+    'scroll_position': (0.0, 0.0),
+    'show_icon_preview': False,
+    'text_size': os.environ['iconTextSize'],
+    'icon_size': os.environ['iconSize'],
+    'include_icon_view_settings': 'auto',
+    'include_list_view_settings': 'auto',
+    'list_icon_size': 16.0,
+    'list_text_size': 12.0,
+    'list_scroll_position': (0, 0),
+    'list_sort_by': 'name',
+    'list_columns': ('name', 'date-modified', 'size', 'kind', 'date-added'),
+    'list_column_widths': {
+      'name': 300,
+      'date-modified': 181,
+      'date-created': 181,
+      'date-added': 181,
+      'date-last-opened': 181,
+      'size': 97,
+      'kind': 115,
+      'label': 100,
+      'version': 75,
+      'comments': 300,
+    },
+    'list_column_sort_directions': {
+      'name': 'ascending',
+      'date-modified': 'descending',
+      'date-created': 'descending',
+      'date-added': 'descending',
+      'date-last-opened': 'descending',
+      'size': 'descending',
+      'kind': 'ascending',
+      'label': 'ascending',
+      'version': 'ascending',
+      'comments': 'ascending',
+    }
+  }
+
+  # Set up the finder data
+  bwsp = {
+    'ShowStatusBar': False,
+    'ContainerShowSidebar': False,
+    'PreviewPaneVisibility': False,
+    'SidebarWidth': options['sidebar_width'],
+    'ShowTabView': False,
+    'ShowToolbar': False,
+    'ShowPathbar': False,
+    'ShowSidebar': False
+  }
+
+  window_x = os.environ.get('windowX')
+  if window_x:
+    window_y = os.environ['windowY']
+    bwsp['WindowBounds'] = '{{%s, %s}, {%s, %s}}' % (window_x,
+                                                     window_y,
+                                                     os.environ['windowWidth'],
+                                                     os.environ['windowHeight'])
+
+  arrange_options = {
+    'name': 'name',
+    'date-modified': 'dateModified',
+    'date-created': 'dateCreated',
+    'date-added': 'dateAdded',
+    'date-last-opened': 'dateLastOpened',
+    'size': 'size',
+    'kind': 'kind',
+    'label': 'label',
+  }
+
+  icvp = {
+    'viewOptionsVersion': 1,
+    'backgroundType': 0,
+    'backgroundColorRed': 1.0,
+    'backgroundColorGreen': 1.0,
+    'backgroundColorBlue': 1.0,
+    'gridOffsetX': float(options['grid_offset'][0]),
+    'gridOffsetY': float(options['grid_offset'][1]),
+    'gridSpacing': float(options['grid_spacing']),
+    'arrangeBy': str(arrange_options.get(options['arrange_by'], 'none')),
+    'showIconPreview': options['show_icon_preview'] == True,
+    'showItemInfo': False,
+    'labelOnBottom': True,
+    'textSize': float(options['text_size']),
+    'iconSize': float(options['icon_size']),
+    'scrollPositionX': float(options['scroll_position'][0]),
+    'scrollPositionY': float(options['scroll_position'][1])
+  }
+
+  columns = {
+    'name': 'name',
+    'date-modified': 'dateModified',
+    'date-created': 'dateCreated',
+    'date-added': 'dateAdded',
+    'date-last-opened': 'dateLastOpened',
+    'size': 'size',
+    'kind': 'kind',
+    'label': 'label',
+    'version': 'version',
+    'comments': 'comments'
+  }
+
+  default_widths = {
+    'name': 300,
+    'date-modified': 181,
+    'date-created': 181,
+    'date-added': 181,
+    'date-last-opened': 181,
+    'size': 97,
+    'kind': 115,
+    'label': 100,
+    'version': 75,
+    'comments': 300,
+  }
+
+  default_sort_directions = {
+    'name': 'ascending',
+    'date-modified': 'descending',
+    'date-created': 'descending',
+    'date-added': 'descending',
+    'date-last-opened': 'descending',
+    'size': 'descending',
+    'kind': 'ascending',
+    'label': 'ascending',
+    'version': 'ascending',
+    'comments': 'ascending',
+  }
+
+  lsvp = {
+    'viewOptionsVersion': 1,
+    'sortColumn': columns.get(options['list_sort_by'], 'name'),
+    'textSize': float(options['list_text_size']),
+    'iconSize': float(options['list_icon_size']),
+    'showIconPreview': options['show_icon_preview'],
+    'scrollPositionX': options['list_scroll_position'][0],
+    'scrollPositionY': options['list_scroll_position'][1],
+    'useRelativeDates': True,
+    'calculateAllSizes': False,
+  }
+
+  lsvp['columns'] = {}
+  cndx = {}
+
+  for n, column in enumerate(options['list_columns']):
+    cndx[column] = n
+    width = options['list_column_widths'].get(column, default_widths[column])
+    asc = 'ascending' == options['list_column_sort_directions'].get(column, default_sort_directions[column])
+
+    lsvp['columns'][columns[column]] = {
+      'index': n,
+      'width': width,
+      'identifier': columns[column],
+      'visible': True,
+      'ascending': asc
+    }
+
+  n = len(options['list_columns'])
+  for k in iterkeys(columns):
+    if cndx.get(k, None) is None:
+      cndx[k] = n
+      width = default_widths[k]
+      asc = 'ascending' == default_sort_directions[k]
+
+    lsvp['columns'][columns[column]] = {
+      'index': n,
+      'width': width,
+      'identifier': columns[column],
+      'visible': False,
+      'ascending': asc
+    }
+
+    n += 1
+
+  default_view = 'icon-view'
+  views = {
+    'icon-view': b'icnv',
+    'column-view': b'clmv',
+    'list-view': b'Nlsv',
+    'coverflow': b'Flwv'
+  }
+
+  icvl = (b'type', views.get(default_view, 'icnv'))
+
+  include_icon_view_settings = default_view == 'icon-view' \
+                               or options['include_icon_view_settings'] not in \
+                               ('auto', 'no', 0, False, None)
+  include_list_view_settings = default_view in ('list-view', 'coverflow') \
+                               or options['include_list_view_settings'] not in \
+                               ('auto', 'no', 0, False, None)
+
+  try:
+    background_bmk = None
+
+    background_color = os.environ.get('backgroundColor')
+    background_file = os.environ.get('backgroundFile')
+
+    if background_color:
+      c = parseColor(background_color).to_rgb()
+
+      icvp['backgroundType'] = 1
+      icvp['backgroundColorRed'] = float(c.r)
+      icvp['backgroundColorGreen'] = float(c.g)
+      icvp['backgroundColorBlue'] = float(c.b)
+    elif background_file:
+      alias = Alias.for_file(background_file)
+      background_bmk = Bookmark.for_file(background_file)
+
+      icvp['backgroundType'] = 2
+      icvp['backgroundImageAlias'] = biplist.Data(alias.to_bytes())
+
+    image_dsstore = os.path.join(os.environ['volumePath'], '.DS_Store')
+
+    f =  "icon_locations = {\n" + os.environ['iconLocations'] + "\n}"
+    exec (f, options, options)
+
+    with DSStore.open(image_dsstore, 'w+') as d:
+      d['.']['vSrn'] = ('long', 1)
+      d['.']['bwsp'] = bwsp
+      if include_icon_view_settings:
+        d['.']['icvp'] = icvp
+        if background_bmk:
+          d['.']['pBBk'] = background_bmk
+      if include_list_view_settings:
+        d['.']['lsvp'] = lsvp
+      d['.']['icvl'] = icvl
+
+      d['.background']['Iloc'] = (2560, 170)
+      d['.DS_Store']['Iloc'] = (2610, 170)
+      d['.fseventsd']['Iloc'] = (2660, 170)
+      d['.Trashes']['Iloc'] = (2710, 170)
+      d['.VolumeIcon.icns']['Iloc'] = (2760, 170)
+
+      for k, v in iteritems(options['icon_locations']):
+        d[k]['Iloc'] = v
+  except:
+    raise
+
+build_dmg()