FILETYPES: Newer XFree86 rgb.txt files use the key Xorg instead of

XConsortium.  Now we can recognize these files!

Tools/pynche/ColorDB.py

@@ -39,42 +39,42 @@ class ColorDB:
     def __init__(self, fp):
         lineno = 2
         self.__name = fp.name
-	# Maintain several dictionaries for indexing into the color database.
+        # Maintain several dictionaries for indexing into the color database.
-	# Note that while Tk supports RGB intensities of 4, 8, 12, or 16 bits, 
+        # Note that while Tk supports RGB intensities of 4, 8, 12, or 16 bits,
-	# for now we only support 8 bit intensities.  At least on OpenWindows, 
+        # for now we only support 8 bit intensities.  At least on OpenWindows,
-	# all intensities in the /usr/openwin/lib/rgb.txt file are 8-bit
+        # all intensities in the /usr/openwin/lib/rgb.txt file are 8-bit
-	#
+        #
-	# key is (red, green, blue) tuple, value is (name, [aliases])
+        # key is (red, green, blue) tuple, value is (name, [aliases])
-	self.__byrgb = {}
+        self.__byrgb = {}
-	# key is name, value is (red, green, blue)
+        # key is name, value is (red, green, blue)
-	self.__byname = {}
+        self.__byname = {}
         # all unique names (non-aliases).  built-on demand
         self.__allnames = None
-	while 1:
+        while 1:
-	    line = fp.readline()
+            line = fp.readline()
-	    if not line:
+            if not line:
-		break
+                break
-	    # get this compiled regular expression from derived class
+            # get this compiled regular expression from derived class
-	    mo = self._re.match(line)
+            mo = self._re.match(line)
-	    if not mo:
+            if not mo:
                 print >> sys.stderr, 'Error in', fp.name, ' line', lineno
-		lineno += 1
+                lineno += 1
-		continue
+                continue
-	    # extract the red, green, blue, and name
+            # extract the red, green, blue, and name
             red, green, blue = self._extractrgb(mo)
             name = self._extractname(mo)
-	    keyname = name.lower()
+            keyname = name.lower()
-	    # BAW: for now the `name' is just the first named color with the
+            # BAW: for now the `name' is just the first named color with the
-	    # rgb values we find.  Later, we might want to make the two word
+            # rgb values we find.  Later, we might want to make the two word
-	    # version the `name', or the CapitalizedVersion, etc.
+            # version the `name', or the CapitalizedVersion, etc.
-	    key = (red, green, blue)
+            key = (red, green, blue)
-	    foundname, aliases = self.__byrgb.get(key, (name, []))
+            foundname, aliases = self.__byrgb.get(key, (name, []))
-	    if foundname <> name and foundname not in aliases:
+            if foundname <> name and foundname not in aliases:
-		aliases.append(name)
+                aliases.append(name)
-	    self.__byrgb[key] = (foundname, aliases)
+            self.__byrgb[key] = (foundname, aliases)
-	    # add to byname lookup
+            # add to byname lookup
-	    self.__byname[keyname] = key
+            self.__byname[keyname] = key
-	    lineno = lineno + 1
+            lineno = lineno + 1
 
     # override in derived classes
     def _extractrgb(self, mo):
@@ -88,36 +88,36 @@ class ColorDB:
 
     def find_byrgb(self, rgbtuple):
         """Return name for rgbtuple"""
-	try:
+        try:
-	    return self.__byrgb[rgbtuple]
+            return self.__byrgb[rgbtuple]
-	except KeyError:
+        except KeyError:
-	    raise BadColor(rgbtuple)
+            raise BadColor(rgbtuple)
 
     def find_byname(self, name):
         """Return (red, green, blue) for name"""
-	name = name.lower()
+        name = name.lower()
-	try:
+        try:
-	    return self.__byname[name]
+            return self.__byname[name]
-	except KeyError:
+        except KeyError:
-	    raise BadColor(name)
+            raise BadColor(name)
 
     def nearest(self, red, green, blue):
         """Return the name of color nearest (red, green, blue)"""
-	# BAW: should we use Voronoi diagrams, Delaunay triangulation, or
+        # BAW: should we use Voronoi diagrams, Delaunay triangulation, or
-	# octree for speeding up the locating of nearest point?  Exhaustive
+        # octree for speeding up the locating of nearest point?  Exhaustive
-	# search is inefficient, but seems fast enough.
+        # search is inefficient, but seems fast enough.
-	nearest = -1
+        nearest = -1
-	nearest_name = ''
+        nearest_name = ''
-	for name, aliases in self.__byrgb.values():
+        for name, aliases in self.__byrgb.values():
-	    r, g, b = self.__byname[name.lower()]
+            r, g, b = self.__byname[name.lower()]
-	    rdelta = red - r
+            rdelta = red - r
-	    gdelta = green - g
+            gdelta = green - g
-	    bdelta = blue - b
+            bdelta = blue - b
-	    distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta
+            distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta
-	    if nearest == -1 or distance < nearest:
+            if nearest == -1 or distance < nearest:
-		nearest = distance
+                nearest = distance
-		nearest_name = name
+                nearest_name = name
-	return nearest_name
+        return nearest_name
 
     def unique_names(self):
         # sorted
@@ -172,6 +172,7 @@ class WebsafeDB(ColorDB):
 # the class to instantiate if a match is found
 
 FILETYPES = [
+    (re.compile('Xorg'), RGBColorDB),
     (re.compile('XConsortium'), RGBColorDB),
     (re.compile('HTML'), HTML40DB),
     (re.compile('lightlink'), LightlinkDB),
@@ -216,11 +217,11 @@ def rrggbb_to_triplet(color):
     if rgbtuple is None:
         if color[0] <> '#':
             raise BadColor(color)
-	red = color[1:3]
+        red = color[1:3]
-	green = color[3:5]
+        green = color[3:5]
-	blue = color[5:7]
+        blue = color[5:7]
         rgbtuple = int(red, 16), int(green, 16), int(blue, 16)
-	_namedict[color] = rgbtuple
+        _namedict[color] = rgbtuple
     return rgbtuple
 
 
@@ -230,8 +231,8 @@ def triplet_to_rrggbb(rgbtuple):
     global _tripdict
     hexname = _tripdict.get(rgbtuple)
     if hexname is None:
-	hexname = '#%02x%02x%02x' % rgbtuple
+        hexname = '#%02x%02x%02x' % rgbtuple
-	_tripdict[rgbtuple] = hexname
+        _tripdict[rgbtuple] = hexname
     return hexname
 
 
@@ -253,17 +254,17 @@ def triplet_to_brightness(rgbtuple):
 if __name__ == '__main__':
     colordb = get_colordb('/usr/openwin/lib/rgb.txt')
     if not colordb:
-	print 'No parseable color database found'
+        print 'No parseable color database found'
-	sys.exit(1)
+        sys.exit(1)
     # on my system, this color matches exactly
     target = 'navy'
     red, green, blue = rgbtuple = colordb.find_byname(target)
     print target, ':', red, green, blue, triplet_to_rrggbb(rgbtuple)
     name, aliases = colordb.find_byrgb(rgbtuple)
     print 'name:', name, 'aliases:', COMMASPACE.join(aliases)
-    r, g, b = (1, 1, 128)			  # nearest to navy
+    r, g, b = (1, 1, 128)                         # nearest to navy
-    r, g, b = (145, 238, 144)			  # nearest to lightgreen
+    r, g, b = (145, 238, 144)                     # nearest to lightgreen
-    r, g, b = (255, 251, 250)			  # snow
+    r, g, b = (255, 251, 250)                     # snow
     print 'finding nearest to', target, '...'
     import time
     t0 = time.time()