Thuban/UI/classifier.py

# Copyright (c) 2001 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""Dialog for classifying how layers are displayed"""

__version__ = "$Revision$"

import copy

from wxPython.wx import *
from wxPython.grid import *

from Thuban import _
from Thuban.common import *
from Thuban.UI.common import *

from Thuban.Model.classification import *

from Thuban.Model.color import Color

from Thuban.Model.layer import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT

ID_PROPERTY_SELECT = 4010
ID_CLASS_TABLE = 40011

ID_CLASSIFY_OK = 4001
ID_CLASSIFY_CANCEL = 4002
ID_CLASSIFY_ADD = 4003
ID_CLASSIFY_GENRANGE = 4004
ID_CLASSIFY_REMOVE = 4005

COL_VISUAL = 0
COL_VALUE  = 1
COL_LABEL  = 2

FIELD_CLASS = 0
FIELD_TYPE = 1
FIELD_NAME = 2

FIELD_TYPE_STRING = "string"
FIELD_TYPE_INT = "int"
FIELD_TYPE_DOUBLE = "double"

#
# this is a silly work around to ensure that the table that is
# passed into SetTable is the same that is returned by GetTable
#
import weakref
class ClassGrid(wxGrid):

    def __init__(self, parent, layer, fieldData):
        wxGrid.__init__(self, parent, ID_CLASS_TABLE, size = (340, 160))
        self.SetSelectionMode(wxGrid.wxGridSelectRows)
        self.SetTable(ClassTable(fieldData, layer.ShapeType(), self), true)
        EVT_GRID_CELL_LEFT_DCLICK(self, self.OnCellDClick)

        EVT_GRID_RANGE_SELECT(self, self._OnSelectedRange)
        EVT_GRID_SELECT_CELL(self, self._OnSelectedCell)

        self.layer = layer
        self.currentSelection = []

    def GetCurrentSelection(self):
        sel = copy.copy(self.currentSelection)
        sel.sort()
        return sel

    def SetCellRenderer(self, row, col):
        raise ValueError(_("Must not allow setting of renderer in ClassGrid!"))

    def SetTable(self, object, *attributes): 
        self.tableRef = weakref.ref(object) 
        return wxGrid.SetTable(self, object, *attributes) 

    def GetTable(self): 
        return self.tableRef() 

    def DeleteSelectedRows(self):
        sel = self.GetCurrentSelection()

        if len(sel) == 0: return
        if len(sel) == 1:
            group = self.GetTable().GetValueAsCustom(sel[0], COL_VISUAL, None)
            if isinstance(group, ClassGroupDefault):
                wxMessageDialog(self, 
                                "The Default group cannot be removed.",
                                style = wxOK | wxICON_EXCLAMATION).ShowModal()
                return
        
        self.ClearSelection()

        sel.reverse()
        table = self.GetTable()
        for row in sel:
            table.DeleteRows(row)

        if len(sel) == 1:
            r = sel[0]
            if r > self.GetNumberRows() - 1:
                r = self.GetNumberRows() - 1
            self.SelectRow(r)
        
#
# XXX: This isn't working, and there is no way to deselect rows wxPython!
#
#   def DeselectRow(self, row):
#       self.ProcessEvent(
#           wxGridRangeSelectEvent(-1, 
#                                  wxEVT_GRID_RANGE_SELECT,
#                                  self,
#                                  (row, row), (row, row),
#                                  sel = False))

    def OnCellDClick(self, event):
        r = event.GetRow()
        c = event.GetCol()
        if c == COL_VISUAL:
            # XXX: getting the properties is only possible with non-Maps!!!
            group = self.GetTable().GetValueAsCustom(r, c, None)
            prop = group.GetProperties()
            propDlg = SelectPropertiesDialog(NULL, prop, self.layer.ShapeType())
            if propDlg.ShowModal() == wxID_OK:
                new_prop = propDlg.GetClassGroupProperties()
                prop.SetStroke(new_prop.GetStroke())
                prop.SetStrokeWidth(new_prop.GetStrokeWidth())
                prop.SetFill(new_prop.GetFill())
                self.Refresh()
            propDlg.Destroy()

    #
    # _OnSelectedRange() and _OnSelectedCell() were borrowed
    # from http://wiki.wxpython.org
    #
    def _OnSelectedRange(self, event): 
        """Internal update to the selection tracking list""" 
        if event.Selecting(): 
            for index in range( event.GetTopRow(), event.GetBottomRow()+1): 
                if index not in self.currentSelection: 
                    self.currentSelection.append( index ) 
        else: 
            for index in range( event.GetTopRow(), event.GetBottomRow()+1): 
                while index in self.currentSelection: 
                    self.currentSelection.remove( index ) 
        #self.ConfigureForSelection() 

        event.Skip() 

    def _OnSelectedCell( self, event ): 
        """Internal update to the selection tracking list""" 
        self.currentSelection = [ event.GetRow() ] 
        #self.ConfigureForSelection() 
        event.Skip() 

class ClassTable(wxPyGridTableBase):

    NUM_COLS = 3

    __col_labels = [_("Symbol"), _("Value"), _("Label")]

    def __init__(self, fieldData, shapeType, view = None):
        wxPyGridTableBase.__init__(self)
        self.SetView(view)
        self.tdata = []

        self.Reset(fieldData, shapeType)

    def Reset(self, fieldData, shapeType):

        self.GetView().BeginBatch()

        self.fieldData = fieldData
        self.shapeType = shapeType
        self.renderer = ClassRenderer(self.shapeType)

        old_len = len(self.tdata)

        self.tdata = []

        clazz = fieldData[FIELD_CLASS]
        if clazz is None:
            clazz = Classification()

#       p = clazz.GetDefaultGroup()
#       np = ClassDataDefault(classData = p)
#       self.tdata.append([np, 'DEFAULT', np.GetLabel()])

#       for p in clazz.points.values():
#           np = ClassDataPoint(p.GetValue(), classData = p)
#           self.tdata.append([np, np.GetValue(), np.GetLabel()])

#       for p in clazz.ranges:
#           np = ClassDataRange(p.GetMin(), p.GetMax(), classData = p)
#           self.tdata.append([np, 
#                              '%s - %s' % (np.GetMin(), np.GetMax()), 
#                              np.GetLabel()])

        i = 0
        for p in clazz:
            np = copy.copy(p)
            self.__SetRow(i, np)
            i += 1

 
        self.modified = 0

        self.__NotifyRowChanges(old_len, len(self.tdata))
        self.GetView().EndBatch()

    def __NotifyRowChanges(self, curRows, newRows):
        #
        # silly message processing for updates to the number of
        # rows and columns
        #
        if newRows > curRows:
            msg = wxGridTableMessage(self,
                        wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
                        newRows - curRows)    # how many
            self.GetView().ProcessTableMessage(msg)
        elif newRows < curRows:
            msg = wxGridTableMessage(self,
                        wxGRIDTABLE_NOTIFY_ROWS_DELETED,
                        curRows - newRows,    # position
                        curRows - newRows)    # how many
            self.GetView().ProcessTableMessage(msg)


    def __SetRow(self, row, group):

        if isinstance(group, ClassGroupDefault):
            data = [group, _('DEFAULT'), group.GetLabel()]
        elif isinstance(group, ClassGroupSingleton):
            data = [group, group.GetValue(), group.GetLabel()]
        elif isinstance(group, ClassGroupRange):
            data = [group, 
                    _('%s - %s') % (group.GetMin(), group.GetMax()), 
                    group.GetLabel()]

        if row >= len(self.tdata):
            self.tdata.append(data)
        else:
            self.tdata[row] = data

    def GetColLabelValue(self, col):
        return self.__col_labels[col]

    def GetRowLabelValue(self, row):
        data = self.tdata[row][COL_VISUAL]
        if isinstance(data, ClassGroupDefault):   return _("Default")
        if isinstance(data, ClassGroupSingleton): return _("Singleton")
        if isinstance(data, ClassGroupRange):     return _("Range")
        if isinstance(data, ClassGroupMap):       return _("Map")

    def GetNumberRows(self):
        return len(self.tdata)

    def GetNumberCols(self):
        return self.NUM_COLS

    def IsEmptyCell(self, row, col):
        return 0

    def GetValue(self, row, col):
        return self.GetValueAsCustom(row, col, "")

    def SetValue(self, row, col, value):
        self.SetValueAsCustom(row, col, "", value)
        self.__Modified()
       
    def GetValueAsCustom(self, row, col, typeName):
        return self.tdata[row][col]

    def __ParseInput(self, value):
        """Try to determine what kind of input value is 
           (a single number or a range)
        """

        type = self.fieldData[FIELD_TYPE]

        if type == FIELD_TYPE_STRING:
            return (value,)
        elif type == FIELD_TYPE_INT or type == FIELD_TYPE_DOUBLE:

            #
            # first try to take the input as a single number
            # if there's an exception try to break it into
            # a range seperated by a '-'. take care to ignore
            # a leading '-' as that could be for a negative number.
            # then try to parse the individual parts. if there
            # is an exception here, let it pass up to the calling
            # function.
            #
            try:
                return (Str2Num(value),)
            except:
                i = value.find('-')
                if i == 0:
                    i = value.find('-', 1)

                return (Str2Num(value[:i]), Str2Num(value[i+1:]))
            

    def SetValueAsCustom(self, row, col, typeName, value):
        group = self.tdata[row][COL_VISUAL]

        if col == COL_VISUAL:
            self.tdata[row][COL_VISUAL] = value
        elif col == COL_VALUE:
            if isinstance(group, ClassGroupDefault):
                # not allowed to modify the default value 
                pass
            elif isinstance(group, ClassGroupMap):
                # something special
                pass
            else: # SINGLETON, RANGE
                try:
                    dataInfo = self.__ParseInput(value)
                except:
                    # bad input, ignore the request
                    pass
                else:

                    ngroup = group
                    props = group.GetProperties()
                    if len(dataInfo) == 1:
                        if not isinstance(group, ClassGroupSingleton):
                            ngroup = ClassGroupSingleton(prop = props)
                        ngroup.SetValue(dataInfo[0])
                    elif len(dataInfo) == 2:
                        if not isinstance(group, ClassGroupRange):
                            ngroup = ClassGroupRange(prop = props)
                        ngroup.SetRange(dataInfo[0], dataInfo[1])
                    else:
                        assert(False)

                    ngroup.SetLabel(group.GetLabel())
                    self.__SetRow(row, ngroup)

                    self.GetView().Refresh()

        elif col == COL_LABEL:
            group.SetLabel(value)
            self.tdata[row][COL_LABEL] = group.GetLabel()
        else:
            raise ValueError(_("Invalid column request"))

        self.__Modified()

    def GetAttr(self, row, col, someExtraParameter):
        attr = wxGridCellAttr()
        #attr = wxPyGridTableBase.GetAttr(self, row, col, someExtraParameter)
 
        if col == COL_VISUAL:
            attr.SetRenderer(ClassRenderer(self.shapeType))
            attr.SetReadOnly()

        return attr

    def GetClassGroup(self, row):
        return self.tdata[row][COL_VISUAL]

    def __Modified(self):
        self.modified = 1

    def IsModified(self):
        return self.modified

    def DeleteRows(self, pos, numRows = 1):
        assert(pos >= 0)
        old_len = len(self.tdata)
        for row in range(pos, pos - numRows, -1):
            group = self.GetValueAsCustom(row, COL_VISUAL, None)
            if not isinstance(group, ClassGroupDefault):
                self.tdata.pop(row)
                self.__Modified()
    
        if self.IsModified():
            self.__NotifyRowChanges(old_len, len(self.tdata))

    def AppendRows(self, numRows = 1):
        old_len = len(self.tdata)
        for i in range(numRows):
            np = ClassGroupSingleton()
            self.tdata.append([np, np.GetValue(), np.GetLabel()])
            self.__Modified()

        if self.IsModified():
            self.__NotifyRowChanges(old_len, len(self.tdata))


class Classifier(wxDialog):
    
    def __init__(self, parent, layer):
        wxDialog.__init__(self, parent, -1, _("Classify"),
                          style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)


        self.layer = layer

        topBox = wxBoxSizer(wxVERTICAL)

        topBox.Add(wxStaticText(self, -1, _("Layer: %s") % layer.Title()),
            0, wxALIGN_LEFT | wxALL, 4) 
        topBox.Add(wxStaticText(self, -1, _("Type: %s") % layer.ShapeType()),
            0, wxALIGN_LEFT | wxALL, 4) 

        propertyBox = wxBoxSizer(wxHORIZONTAL)
        propertyBox.Add(wxStaticText(self, -1, _("Field: ")),
            0, wxALIGN_CENTER | wxALL, 4)

        self.fields = wxComboBox(self, ID_PROPERTY_SELECT, "",
                                     style = wxCB_READONLY)

        self.num_cols = layer.table.field_count()
        # just assume the first field in case one hasn't been
        # specified in the file.
        self.__cur_field = 0 
        clazz = layer.GetClassification()
        field = clazz.GetField()
        for i in range(self.num_cols):
            type, name, len, decc = layer.table.field_info(i)
            self.fields.Append(name)

            if name == field:
                self.__cur_field = i
                self.fields.SetClientData(i, [clazz, type, name, len, decc])
            else:
                self.fields.SetClientData(i, [None, type, name, len, decc])

        self.fields.SetSelection(self.__cur_field)

        propertyBox.Add(self.fields, 1, wxGROW|wxALL, 4)
        EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnFieldSelect)

        topBox.Add(propertyBox, 0, wxGROW, 4)

        #
        # Classification data table
        #

        controlBox = wxBoxSizer(wxHORIZONTAL)
        self.classGrid = ClassGrid(self, 
                                   layer,
                                   self.fields.GetClientData(self.__cur_field)) 

        controlBox.Add(self.classGrid, 1, wxGROW, 0)

        controlButtonBox = wxBoxSizer(wxVERTICAL)
        controlButtonBox.Add(wxButton(self, ID_CLASSIFY_ADD, 
            _("Add")), 0, wxGROW | wxALL, 4)
        controlButtonBox.Add(wxButton(self, ID_CLASSIFY_GENRANGE, 
            _("Generate Ranges")), 0, wxGROW | wxALL, 4)

        controlButtonBox.Add(wxButton(self, ID_CLASSIFY_REMOVE, 
            _("Remove")), 0, wxGROW | wxALL | wxALIGN_BOTTOM, 4)

        controlBox.Add(controlButtonBox, 0, wxGROW, 10)
        topBox.Add(controlBox, 1, wxGROW, 10)

        EVT_BUTTON(self, ID_CLASSIFY_ADD, self.OnAdd)
        EVT_BUTTON(self, ID_CLASSIFY_REMOVE, self.OnRemove)
        EVT_BUTTON(self, ID_CLASSIFY_GENRANGE, self.OnGenRange)

        #
        # Control buttons:
        #
        buttonBox = wxBoxSizer(wxHORIZONTAL)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
                      0, wxALL, 4)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
                      0, wxALL, 4)
        topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 10)

        EVT_BUTTON(self, ID_CLASSIFY_OK, self.OnOK)
        EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self.OnCancel)


        self.SetAutoLayout(true)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self) 

    def __BuildClassification(self, prop):

        clazz = Classification()
        clazz.SetField(self.fields.GetString(prop))

        numRows = self.classGrid.GetNumberRows()

        if numRows > 0:
            table = self.classGrid.GetTable()
            clazz.SetDefaultGroup(table.GetClassGroup(0))

            for i in range(1, numRows):
                clazz.AddGroup(table.GetClassGroup(i))

        return clazz

    def OnFieldSelect(self, event): 
        data = self.fields.GetClientData(self.__cur_field)
        data[FIELD_CLASS] = self.__BuildClassification(self.__cur_field)

        self.fields.SetClientData(self.__cur_field, data)

        self.__cur_field = self.fields.GetSelection()
        fieldData = self.fields.GetClientData(self.__cur_field)
        self.classGrid.GetTable().Reset(fieldData, self.layer.ShapeType())

    def OnOK(self, event):
        """Put the data from the table into a new Classification and hand
           it to the layer.
        """

        clazz = self.fields.GetClientData(self.__cur_field)[FIELD_CLASS]

        #
        # only build the classification if there wasn't one to
        # to begin with or it has been modified
        #
        if clazz is None or self.classGrid.GetTable().IsModified():
            clazz = self.__BuildClassification(self.__cur_field)

        clazz.SetLayer(self.layer)

        self.layer.SetClassification(clazz)

        self.EndModal(wxID_OK)

    def OnCancel(self, event):
        """Do nothing. The layer's current classification stays the same."""
        self.EndModal(wxID_CANCEL)

    def OnAdd(self, event): 
        self.classGrid.AppendRows()

    def OnRemove(self, event):
        self.classGrid.DeleteSelectedRows()

    def OnGenRange(self, event):
        print "Classifier.OnGenRange()"


ID_SELPROP_OK = 4001
ID_SELPROP_CANCEL = 4002
ID_SELPROP_SPINCTRL = 4002
ID_SELPROP_PREVIEW = 4003
ID_SELPROP_STROKECLR = 4004
ID_SELPROP_FILLCLR = 4005

class SelectPropertiesDialog(wxDialog):

    def __init__(self, parent, prop, shapeType):
        wxDialog.__init__(self, parent, -1, _("Select Properties"),
                          style = wxRESIZE_BORDER)

        self.prop = ClassGroupProperties(prop)

        topBox = wxBoxSizer(wxVERTICAL)

        itemBox = wxBoxSizer(wxHORIZONTAL)

        # preview box
        previewBox = wxBoxSizer(wxVERTICAL)
        previewBox.Add(wxStaticText(self, -1, _("Preview:")),
            0, wxALIGN_LEFT | wxALL, 4)
        self.previewer = ClassDataPreviewer(None, self.prop, shapeType, 
                                            self, ID_SELPROP_PREVIEW, (40, 40))
        previewBox.Add(self.previewer, 1, wxGROW, 15)

        itemBox.Add(previewBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)

        # control box
        ctrlBox = wxBoxSizer(wxVERTICAL)
        ctrlBox.Add(
            wxButton(self, ID_SELPROP_STROKECLR, "Change Stroke Color"),
            1, wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
        EVT_BUTTON(self, ID_SELPROP_STROKECLR, self.OnChangeStrokeColor)

        if shapeType != SHAPETYPE_ARC:
            ctrlBox.Add(
                wxButton(self, ID_SELPROP_FILLCLR, "Change Fill Color"),
                0, wxALIGN_LEFT | wxALL | wxGROW, 4)
            EVT_BUTTON(self, ID_SELPROP_FILLCLR, self.OnChangeFillColor)

        spinBox = wxBoxSizer(wxHORIZONTAL)
        spinBox.Add(wxStaticText(self, -1, _("Stroke Width: ")),
                0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4) 
        self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL, 
                                   min=1, max=10, 
                                   value=str(prop.GetStrokeWidth()),
                                   initial=prop.GetStrokeWidth())

        EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self.OnSpin)

        spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT | wxALL, 4) 

        ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
        itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)
        topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)


        #
        # Control buttons:
        #
        buttonBox = wxBoxSizer(wxHORIZONTAL)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
                      0, wxALL, 4)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
                      0, wxALL, 4)
        topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 10)
                                                                                
        EVT_BUTTON(self, ID_SELPROP_OK, self.OnOK)
        EVT_BUTTON(self, ID_SELPROP_CANCEL, self.OnCancel)
                                                                                
        self.SetAutoLayout(true)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self)

    def OnOK(self, event):
        self.EndModal(wxID_OK)

    def OnCancel(self, event):
        self.EndModal(wxID_CANCEL)

    def OnSpin(self, event):
        self.prop.SetStrokeWidth(self.spinCtrl.GetValue())
        self.previewer.Refresh()

    def __GetColor(self, cur):
        dialog = wxColourDialog(self)
        dialog.GetColourData().SetColour(Color2wxColour(cur))
        ret = None
        if dialog.ShowModal() == wxID_OK:
            ret = wxColour2Color(dialog.GetColourData().GetColour())

        dialog.Destroy()

        return ret
        
    def OnChangeStrokeColor(self, event):
        clr = self.__GetColor(self.prop.GetStroke())
        if clr is not None:
            self.prop.SetStroke(clr)
        self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer

    def OnChangeFillColor(self, event):
        clr = self.__GetColor(self.prop.GetFill())
        if clr is not None:
            self.prop.SetFill(clr)
        self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer

    def GetClassGroupProperties(self):
        return self.prop


class ClassDataPreviewer(wxWindow):

    def __init__(self, rect, prop, shapeType, 
                       parent = None, id = -1, size = wxDefaultSize):
        if parent is not None:
            wxWindow.__init__(self, parent, id, size=size)
            EVT_PAINT(self, self.OnPaint)

        self.rect = rect
        self.prop = prop
        self.shapeType = shapeType

    def OnPaint(self, event):
        dc = wxPaintDC(self)

        # XXX: this doesn't seem to be having an effect:
        dc.DestroyClippingRegion() 

        self.Draw(dc, None)

    def Draw(self, dc, rect, prop = None, shapeType = None):

        if prop is None: prop = self.prop
        if shapeType is None: shapeType = self.shapeType

        if rect is None:
            x = y = 0
            w, h = self.GetClientSizeTuple()
        else:
            x = rect.GetX()
            y = rect.GetY()
            w = rect.GetWidth()
            h = rect.GetHeight()

        stroke = prop.GetStroke()
        if stroke is Color.None:
            pen = wxTRANSPARENT_PEN
        else:
            pen = wxPen(Color2wxColour(stroke),
                        prop.GetStrokeWidth(),
                        wxSOLID)

        stroke = prop.GetFill()
        if stroke is Color.None:
            brush = wxTRANSPARENT_BRUSH
        else:
            brush = wxBrush(Color2wxColour(stroke), wxSOLID)

        dc.SetPen(pen)
        dc.SetBrush(brush)

        if shapeType == SHAPETYPE_ARC:
            dc.DrawSpline([wxPoint(x, y + h),
                           wxPoint(x + w/2, y + h/4),
                           wxPoint(x + w/2, y + h/4*3),
                           wxPoint(x + w, y)])

        elif shapeType == SHAPETYPE_POINT or \
             shapeType == SHAPETYPE_POLYGON:

            dc.DrawCircle(x + w/2, y + h/2,
                          (min(w, h) - prop.GetStrokeWidth())/2)

class ClassRenderer(wxPyGridCellRenderer):

    def __init__(self, shapeType):
        wxPyGridCellRenderer.__init__(self)
        self.previewer = ClassDataPreviewer(None, None, shapeType)

    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
        data = grid.GetTable().GetValueAsCustom(row, col, None)

        dc.SetClippingRegion(rect.GetX(), rect.GetY(), 
                             rect.GetWidth(), rect.GetHeight())
        dc.SetPen(wxPen(wxLIGHT_GREY))
        dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
        dc.DrawRectangle(rect.GetX(), rect.GetY(), 
                         rect.GetWidth(), rect.GetHeight())

        if not isinstance(data, ClassGroupMap):
            self.previewer.Draw(dc, rect, data.GetProperties())

        if isSelected:
            dc.SetPen(wxPen(wxColour(0 * 255, 0 * 255, 0 * 255),
                      4, wxSOLID))
            dc.SetBrush(wxTRANSPARENT_BRUSH)
            dc.DrawRectangle(rect.GetX(), rect.GetY(), 
                             rect.GetWidth(), rect.GetHeight())

        dc.DestroyClippingRegion()

Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision