Prepared buildtools for Safari

packagerChrome.py

 # coding: utf-8
 
 # This file is part of the Adblock Plus build tools,
 # Copyright (C) 2006-2013 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 
 import sys, os, re, json, struct
 from StringIO import StringIO
 
+import PIL.Image
+import PIL.ImageMath
+
 import packager
 from packager import readMetadata, getMetadataPath, getDefaultFileName, getBuildVersion, getTemplate, Files
 
 defaultLocale = 'en_US'
 
 def getIgnoredFiles(params):
   result = set(('store.description',))
 
   # Hack: ignore all lib subdirectories
   libDir = os.path.join(params['baseDir'], 'lib')
@@ skipping 241 matching lines @@
       'pt': 'pt_PT',
     }
     for chromeLocale, operaLocale in operaMapping.iteritems():
       chromeFile = '_locales/%s/messages.json' % chromeLocale
       operaFile = '_locales/%s/messages.json' % operaLocale if operaLocale != None else None
       if chromeFile in files:
         if operaFile != None:
           files[operaFile] = files[chromeFile]
         del files[chromeFile]
 
-    # Hack: Replace "Chrome" by "Opera" in the locales
+  if params['type'] in ('opera', 'safari'):
+    # Hack: Replace "Chrome" by "Opera" or "Safari" in the locales
     for path, data in files.iteritems():
       if path.startswith("_locales/") and path.endswith("/messages.json"):
-        files[path] = re.sub(r"\bChrome\b", "Opera", data)
+        files[path] = re.sub(r"\bChrome\b", params['type'].capitalize(), data)
 
 def signBinary(zipdata, keyFile):
   import M2Crypto
   if not os.path.exists(keyFile):
     M2Crypto.RSA.gen_key(1024, 65537, callback=lambda x: None).save_key(keyFile, cipher=None)
   key = M2Crypto.EVP.load_key(keyFile)
   key.sign_init()
   key.sign_update(zipdata)
   return key.final()
 
 def getPublicKey(keyFile):
   import M2Crypto
   return M2Crypto.EVP.load_key(keyFile).as_der()
 
 def writePackage(outputFile, pubkey, signature, zipdata):
   if isinstance(outputFile, basestring):
     file = open(outputFile, 'wb')
   else:
     file = outputFile
   if pubkey != None and signature != None:
     file.write(struct.pack('<4sIII', 'Cr24', 2, len(pubkey), len(signature)))
     file.write(pubkey)
     file.write(signature)
   file.write(zipdata)
 
+class ImageConverter(object):
+  def convert(self, params, files):
+    for filename, chain in params['metadata'].items('convert_img'):
+      steps = re.split(r'\s*->\s*', chain)
+      image = PIL.Image.open(steps.pop(0))
+
+      for step in steps:
+        filter, args = re.match(r'([^(]+)(?:\((.*)\))?', step).groups()
+        args = tuple(re.split(r'\s*,\s*', args)) if args else ()
+        image = getattr(self, 'filter_' + filter)(image, *args)
+
+      f = StringIO()
+      f.name = filename
+      image.save(f)
+      files[filename] = f.getvalue()
+
+  def filter_blend(self, image, *args):
+    if len(args) == 2:    # args = (filename, opacity)
+      overlay = PIL.Image.open(args[0])
+
+      if image.mode != overlay.mode or image.mode == 'P':
+        overlay = overlay.convert('RGBA')
+        image   =   image.convert('RGBA')
+    elif len(args) == 4:  # args = (red, green, blue, opacity)
+      overlay = PIL.Image.new('RGB', image.size, tuple(map(int, args[:3])))
+
+      if image.mode == 'P':
+        image = image.convert('RGBA')
+
+      if image.mode in ('RGBA', 'LA'):
+        overlay = PIL.Image.merge('RGBA', overlay.split() + image.split()[-1:])
+
+      if image.mode != overlay.mode:
+        image = image.convert(overlay.mode)
+    else:
+      raise TypeError
+
+    return PIL.Image.blend(image, overlay, float(args[-1]))
+
+  def filter_grayscale(self, image):
+    if image.mode == 'P':
+      image = image.convert('RGBA')
+
+    bands = list(image.split())
+    alpha = bands.pop(-1) if image.mode in ('RGBA', 'LA') else None
+
+    if len(bands) == 1:
+      return image
+
+    new_image = PIL.ImageMath.eval(
+      "convert((%s) / %d, 'L')" % (
+        ' + '.join('image%d' % i for i in xrange(len(bands))),
+        len(bands)
+      ),
+      **dict(('image%d' % i, band) for i, band in enumerate(bands))
+    )
+
+    if alpha:
+      new_image = PIL.Image.merge('LA', [new_image, alpha])
+
+    return new_image
+
+  def filter_colorToAlpha(self, image, *color):
+    bands = [band.convert('F') for band in image.convert('RGBA').split()]
+    color = map(float, color)
+
+    # Find the maximum difference rate between source and color. I had to use two
+    # difference functions because ImageMath.eval only evaluates the expression
+    # once.
+    alpha = PIL.ImageMath.eval('''\
+      float(
+        max(
+          max(
+            max(
+              difference1(red_band, cred_band),
+              difference1(green_band, cgreen_band)
+            ),
+            difference1(blue_band, cblue_band)
+          ),
+          max(
+            max(
+              difference2(red_band, cred_band),
+              difference2(green_band, cgreen_band)
+            ),
+            difference2(blue_band, cblue_band)
+          )
+        )
+      )''',
+      difference1=lambda source, col: (source - col) / (255.0 - col),
+      difference2=lambda source, col: (col - source) / col,
+
+      red_band  = bands[0],
+      green_band= bands[1],
+      blue_band = bands[2],
+
+      cred_band  = color[0],
+      cgreen_band= color[1],
+      cblue_band = color[2],
+    )
+
+    # Calculate the new image colors after the removal of the selected color
+    new_bands = [
+      PIL.ImageMath.eval(
+        "convert((image - color) / alpha + color, 'L')",
+        image=band,
+        color=col,
+        alpha=alpha
+      )
+      for band, col in zip(bands, color)
+    ]
+
+    # Add the new alpha band
+    new_bands.append(PIL.ImageMath.eval(
+      "convert(alpha_band * alpha, 'L')",
+      alpha = alpha,
+      alpha_band = bands[3]
+    ))
+
+    return PIL.Image.merge('RGBA', new_bands)
+
 def createBuild(baseDir, type='chrome', outFile=None, buildNum=None, releaseBuild=False, keyFile=None, experimentalAPI=False, devenv=False):
   metadata = readMetadata(baseDir, type)
   version = getBuildVersion(baseDir, metadata, releaseBuild, buildNum)
 
   if outFile == None:
     outFile = getDefaultFileName(baseDir, metadata, version, 'crx' if keyFile else 'zip')
 
   params = {
     'type': type,
     'baseDir': baseDir,
     'releaseBuild': releaseBuild,
     'version': version,
     'experimentalAPI': experimentalAPI,
     'devenv': devenv,
     'metadata': metadata,
   }
 
   files = Files(getPackageFiles(params), getIgnoredFiles(params),
                 process=lambda path, data: processFile(path, data, params))
   files['manifest.json'] = createManifest(params)
   if metadata.has_section('mapping'):
     files.readMappedFiles(metadata.items('mapping'))
   files.read(baseDir)
 
   if metadata.has_section('convert_js'):
     convertJS(params, files)
 
+  if metadata.has_section('convert_img'):
+    ImageConverter().convert(params, files)
+
   if metadata.has_section('import_locales'):
     importGeckoLocales(params, files)
 
   if devenv:
     files['devenvPoller__.js'] = createPoller(params)
 
   if (metadata.has_option('general', 'backgroundScripts') and
       'lib/info.js' in re.split(r'\s+', metadata.get('general', 'backgroundScripts')) and
       'lib/info.js' not in files):
     files['lib/info.js'] = createInfoModule(params)
@@ skipping 31 matching lines @@
   def shutdown_server(server):
     time.sleep(10)
     server.shutdown()
   thread.start_new_thread(shutdown_server, (server,))
   server.serve_forever()
 
   if connections[0] == 0:
     print 'Warning: No incoming connections, extension probably not active in the browser yet'
   else:
     print 'Handled %i connection(s)' % connections[0]