title: PyQt QTableView not displaying icons after update to PyQt 4.5.1
body: <p>I'll try to be as clear as possible, though this is all a bit muddled in my head.</p>
  
  <p>I have a PyQt application that has been working for about a year now.  After updating to PyQt 4.5.1 (from 4.3.3) none of my icons appear in the QTableView anymore (this update was concurrent with an update to python 2.6.5 from 2.5.1).  Reverting to the older python and PyQt, everything works as expected.</p>
  
  <p>The breakdown is this:</p>
  
  <p>I am using the model-view methodology.  My model, when requested via a Qt.DecorationRole in the data() method, will return a custom object (ColorSwatch) that is a subclass of the QIcon class. This has always worked (with the caveat that I, for reasons I don't understand, have to recast it as a QVariant first).  After updating to PyQt 4.5.1 it <em>appears</em> to run correctly (i.e. I am not getting any errors), but the icon does not draw (though the space where it would be drawn is "reserved" i.e. the text has been shifted to the right to make way for this invisible icon).</p>
  
  <p>Here are some things that I have tried:</p>
  
  <p>I have verified that the ColorSwatch class does still function. This same class is used to draw icons into a contextual menu - and they appear correctly.</p>
  
  <p>I have verified that the data() method is actually getting called and is returning this ColorSwatch object (recast into a QVariant &lt;- though I have tested without this recasting as well).</p>
  
  <p>Pouring snake blood onto my keyboard and lighting it afire.</p>
  
  <p>Nothing so far has given me any clue as to what I should do.  Any hints would be greatly appreciated.  Thanks.</p>
  
  <p>Here is some of the (potentially) relevant code (note that paramObj.get_icon() returns a ColorSwatch object):</p>
  
  <pre><code>#---------------------------------------------------------------------------
  def data(self, index, role=QtCore.Qt.DisplayRole):
      """
      Returns the text or formatting for a particular cell, depending on the 
      role supplied.
      """
  
  
      blah
      blah
      blah
  
  
  
      elif role == QtCore.Qt.DecorationRole:
          if platform.system()=='Darwin':
              return QtGui.QIcon(paramObj.get_icon())
          else:
              return QtCore.QVariant(paramObj.get_icon())
  </code></pre>
  
  <p>and</p>
  
  <pre><code>import os
  import tempfile
  import sys
  import colorsys
  import copy
  import fnmatch
  import time
  
  from PyQt4 import QtGui
  from PyQt4 import QtCore
  
  
  ################################################################################
  class ColorSwatch(QtGui.QIcon):
      """
      A subclass of QIcon, this class draws a colored paint chip with a border
      The color and size are determined at construction time, and cannot
      be changed later.
      """
  
      #---------------------------------------------------------------------------
      def __init__(self, r=1, g=1, b=1, br = 0, bg = 0, bb = 0, w=20, h=20):
          """
          Constructor for the ColorSwatch class. Takes the passed arguments and
          creates a square icon filled with the given color and with a border
          color determined by br, bg, bb. All colors should be in floating point
          format.
          """
          QtGui.QIcon.__init__(self)
  
          #normalize the color
          r8, g8, b8 = self.normalize_color((r, g, b))
  
          #convert the r, g, b values to 8 bit colors
          r8, g8, b8 = self.fp_to_8b_color((r8, g8, b8))
  
          #Create the pixmap and painter objects
          paintChip = QtGui.QPixmap(w, h)
          painter = QtGui.QPainter()
          painter.begin(paintChip)
  
          #fill the swatch
          baseColor = QtGui.QColor(r8, g8, b8)
          painter.fillRect(0, 0, w, h, baseColor)
  
          #if any of the values were super brights (&gt;1), draw a smaller, white
          #box inset to make sure the user knows
          if r &gt; 1 or g &gt; 1 or b &gt; 1:
              painter.fillRect(5, 5, w-10, h-10, QtGui.QColor(255, 255, 255))
  
          #if all values are 0, put a faint x through the icon
  # # #         brush = QtGui.QBrush()
  # # #         brush.setColor(QtGui.QColor(30, 30, 30))
          painter.setPen(QtGui.QColor(200, 200, 200))
          if r ==0 and g == 0 and b == 0:
              painter.drawLine(0, 0, w, h)
              painter.drawLine(w-1, 0, -1, h)
  # # #         
  # # #         #normalize the color
  # # #         r8, g8, b8 = self.normalize_color((r8, g8, b8))
  
          #now draw the border(s)
          #convert the r, g, b values to 8 bit colors
          r8, g8, b8 = self.fp_to_8b_color((br, bg, bb))
  
          #draw the border
          painter.setPen(QtGui.QColor(r8, g8, b8))
          painter.drawRect(0,0,w-1,h-1)
  
          #if any of the values were super brights (&gt;1), draw a border around the
          #inset box as well.
          if r &gt; 1 or g &gt; 1 or b &gt; 1:
              painter.drawRect(5,5,w-11,h-11)
  
          #done drawing
          painter.end()
  
          #add it (both to the normal and the selected modes)
          self.addPixmap(paintChip, QtGui.QIcon.Normal)
          self.addPixmap(paintChip, QtGui.QIcon.Selected)
  
  
      #---------------------------------------------------------------------------
      def fp_to_8b_color(self, color):
          """
          Convert a floating point color value (passed in the form of a three 
          element tuple) to a regular 8-bit 0-255 value. Returns a 3 item tuple.
          """
          r = max(min(int(color[0]*255),255),0)
          g = max(min(int(color[1]*255),255),0)
          b = max(min(int(color[2]*255),255),0)
          return (r,g,b)
  
  
      #---------------------------------------------------------------------------
      def normalize_color(self, color):
          """
          "normalizes" a color value so that if there are any super-whites, it 
          balances all the other floating point values so that we end up with a 
          "real" color.  Negative values will result in undefined behavior.
          Mainly used to make the color chip "look right" when using super whites.
          """
          maxValue = max(color)
          if maxValue &gt; 1:
              return (color[0]/maxValue, color[1]/maxValue, color[2]/maxValue)
          else:
              return color
  </code></pre>