Changeset 1788

Show
Ignore:
Timestamp:
01/14/06 07:54:19 (3 years ago)
Author:
ed
Message:

Revamped the internals of dFont. Rather than be attribute-centric, and only resorting to manipulating the wx.Font when necessary, it now works directly with a wx.Font object. Added a property 'NativeObject?' that is the reference to this object.

Added 'defaultFontSize' to settings.py

Updated the font handling in dGrid and dTreeView. The grid stuff seems to be working correctly, but the Tree View is still kinda funky in parts. This isn't necessarily our fault, since the tree nodes handle fonts differently than other wx objects. The standard wx.Font objects don't work with tree nodes, so there doesn't seem to be much else that can be done.

Cleaned up some spacing in dLabel.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/dabo/settings.py

    r1723 r1788  
    9191# dateFormat = "European"       # DD.MM.YYYY 
    9292 
     93# Default font size when none other is specified 
     94defaultFontSize = 10 
     95 
    9396 
    9497### Settings - end 

  • trunk/dabo/ui/uiwx/dFont.py

    r1787 r1788  
     1import wx 
    12import dabo 
    23from dabo.dObject import dObject 
    …… 
    67class dFont(dObject): 
    78    """This class wraps the various font properties into a single object.""" 
    8     def __init__(self, properties=None, *args, **kwargs): 
    9         self._bold = None 
    10         self._description = None 
    11         self._face = None 
    12         self._italic = None 
    13         self._size = None 
    14         self._underline = None 
    15         # Some internal Dabo tools may need to access the platform-native 
    16         # font object. This attribute holds that object, if any. 
    17         self._baseObject = None 
     9    def __init__(self, properties=None, font=None, *args, **kwargs): 
     10        if font is not None: 
     11            self._nativeObject = font 
     12        else: 
     13            self._nativeObject = wx.Font(dabo.settings.defaultFontSize,  
     14                    wx.DEFAULT, wx.NORMAL, wx.NORMAL) 
     15     
    1816        super(dFont, self).__init__(properties=properties, *args, **kwargs) 
    1917 
    20  
     18     
    2119    def _getBold(self): 
    22         return self._bold 
     20        return (self._nativeObject.GetWeight() == wx.BOLD) 
    2321 
    2422    def _setBold(self, val): 
    25         self._bold = val 
     23        if val: 
     24            self._nativeObject.SetWeight(wx.BOLD) 
     25        else: 
     26            self._nativeObject.SetWeight(wx.LIGHT) 
    2627 
    2728 
    2829    def _getDescription(self): 
    29         return self._description 
    30  
    31     def _setDescription(self, val): 
    32         self._description = val 
     30        ret = self.Face + " " + str(self.Size) 
     31        if self.Bold: 
     32            ret += " B" 
     33        if self.Italic: 
     34            ret += " I" 
     35        return ret 
    3336 
    3437 
    3538    def _getFace(self): 
    36         return self._face 
     39        return self._nativeObject.GetFaceName() 
    3740 
    3841    def _setFace(self, val): 
    39         self._face = val 
     42        self._nativeObject.SetFaceName(val) 
    4043 
    4144 
    4245    def _getItalic(self): 
    43         return self._italic 
     46        return (self._nativeObject.GetStyle() == wx.ITALIC) 
    4447 
    4548    def _setItalic(self, val): 
    46         self._italic = val 
     49        if val: 
     50            self._nativeObject.SetStyle(wx.ITALIC) 
     51        else: 
     52            self._nativeObject.SetStyle(wx.NORMAL) 
     53 
     54 
     55    def _getNativeObject(self): 
     56        return self._nativeObject 
     57 
     58    def _setNativeObject(self, val): 
     59        self._nativeObject = val 
    4760 
    4861 
    4962    def _getSize(self): 
    50         return self._size 
     63        return self._nativeObject.GetPointSize() 
    5164 
    5265    def _setSize(self, val): 
    53         self._size = val 
     66        self._nativeObject.SetPointSize(val) 
    5467 
    5568 
    5669    def _getUnderline(self): 
    57         return self._underline 
     70        return self._nativeObject.GetUnderlined() 
    5871 
    5972    def _setUnderline(self, val): 
    60         self._underline = val 
     73        self._nativeObject.SetUnderlined(val) 
    6174 
    6275 
    …… 
    6477            _("Bold setting for this font  (bool)")) 
    6578     
    66     Description = property(_getDescription, _setDescription, None, 
     79    Description = property(_getDescription, None, None, 
    6780            _("Read-only plain text description of the font  (str)")) 
    6881     
    …… 
    7386            _("Italic setting for this font  (bool)")) 
    7487     
     88    NativeObject = property(_getNativeObject, _setNativeObject, None, 
     89            _("UI toolkit-specific font object  (wx.Font)")) 
     90     
    7591    Size = property(_getSize, _setSize, None, 
    7692            _("Size in points for this font  (int)")) 

  • trunk/dabo/ui/uiwx/dGrid.py

    r1784 r1788  
    354354        kwargs["Parent"] = parent 
    355355        # dColumn maintains one attr object that the grid table will use: 
    356         a = self._gridColAttr = parent._defaultGridColAttr.Clone() 
    357         a.SetFont(self._getDefaultFont()) 
     356        att = self._gridColAttr = parent._defaultGridColAttr.Clone() 
     357        att.SetFont(self._getDefaultFont().NativeObject) 
    358358 
    359359        super(dColumn, self).__init__(properties, *args, **kwargs) 
    …… 
    406406 
    407407    def _getDefaultFont(self): 
    408         font = wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.LIGHT) 
    409         if sys.platform[:3] == "win": 
     408        ret = dabo.ui.dFont(Size=10, Bold=False, Italic=False,  
     409                Underline=False) 
     410        if sys.platform.startswith("win"): 
    410411            # The wx default is quite ugly 
    411             font.SetFaceName("Arial") 
    412             font.SetPointSize(9) 
    413         return font 
     412            ret.Face = "Arial" 
     413            ret.Size = 9 
     414        return ret 
    414415 
    415416 
    …… 
    695696 
    696697    def _getFont(self): 
    697         return self._gridColAttr.GetFont() 
     698        return dabo.ui.dFont(font=self._gridColAttr.GetFont()) 
    698699     
    699700    def _setFont(self, val): 
    700701        if self._constructed(): 
    701             assert isinstance(val, wx.Font) 
    702             self._gridColAttr.SetFont(val) 
     702            if not isinstance(val, dabo.ui.dFont): 
     703                # This will help make sure that any old-style font references 
     704                # are caught. 
     705                dabo.errorLog.write("Incorrect font type passed") 
     706                dabo.dBug.logPoint() 
     707                return 
     708            self._gridColAttr.SetFont(val.NativeObject) 
    703709            self._refreshGrid() 
    704710        else: 
    …… 
    707713     
    708714    def _getFontBold(self): 
    709         return self.Font.GetWeight() == wx.BOLD 
     715        return self.Font.Bold 
    710716     
    711717    def _setFontBold(self, val): 
    712718        if self._constructed(): 
    713             font = self.Font 
    714             if val: 
    715                 font.SetWeight(wx.BOLD) 
    716             else: 
    717                 font.SetWeight(wx.LIGHT) 
    718             self.Font = font 
     719            self.Font.Bold = val 
     720            self._gridColAttr.SetFont(self.Font.NativeObject) 
     721            self._refreshGrid() 
    719722        else: 
    720723            self._properties["FontBold"] = val 
    721724 
     725 
    722726    def _getFontDescription(self): 
    723         f = self.Font 
    724         ret = f.GetFaceName() + " " + str(f.GetPointSize()) 
    725         if f.GetWeight() == wx.BOLD: 
    726             ret += " B" 
    727         if f.GetStyle() == wx.ITALIC: 
    728             ret += " I" 
    729         return ret 
     727        return self.Font.Description 
     728     
    730729     
    731730    def _getFontInfo(self): 
    732         return self.Font.GetNativeFontInfoDesc() 
     731        return self.Font.NativeObject.GetNativeFontInfoDesc() 
    733732 
    734733         
    735734    def _getFontItalic(self): 
    736         return self.Font.GetStyle() == wx.ITALIC 
     735        return self.Font.Italic 
    737736     
    738737    def _setFontItalic(self, val): 
    739738        if self._constructed(): 
    740             font = self.Font 
    741             if val: 
    742                 font.SetStyle(wx.ITALIC) 
    743             else: 
    744                 font.SetStyle(wx.NORMAL) 
    745             self.Font = font 
     739            self.Font.Italic = val 
     740            self._gridColAttr.SetFont(self.Font.NativeObject) 
     741            self._refreshGrid() 
    746742        else: 
    747743            self._properties["FontItalic"] = val 
    …… 
    749745     
    750746    def _getFontFace(self): 
    751         return self.Font.GetFaceName() 
     747        return self.Font.Face 
    752748 
    753749    def _setFontFace(self, val): 
    754750        if self._constructed(): 
    755             f = self.Font 
    756             f.SetFaceName(val) 
    757             self.Font = f 
     751            self.Font.Face = val 
     752            self._gridColAttr.SetFont(self.Font.NativeObject) 
     753            self._refreshGrid() 
    758754        else: 
    759755            self._properties["FontFace"] = val 
    …… 
    761757     
    762758    def _getFontSize(self): 
    763         return self.Font.GetPointSize() 
     759        return self.Font.Size 
    764760     
    765761    def _setFontSize(self, val): 
    766762        if self._constructed(): 
    767             font = self.Font 
    768             font.SetPointSize(int(val)) 
    769             self.Font = font 
     763            self.Font.Size = val 
     764            self._gridColAttr.SetFont(self.Font.NativeObject) 
     765            self._refreshGrid() 
    770766        else: 
    771767            self._properties["FontSize"] = val 
    772768     
     769 
    773770    def _getFontUnderline(self): 
    774         return self.Font.GetUnderlined() 
     771        return self.Font.Underline 
    775772     
    776773    def _setFontUnderline(self, val): 
    777774        if self._constructed(): 
    778             # underlining doesn't seem to be working... 
    779             font = self.Font 
    780             font.SetUnderlined(bool(val)) 
    781             self.Font = font 
     775            self.Font.Underline = val 
     776            self._gridColAttr.SetFont(self.Font.NativeObject) 
     777            self._refreshGrid() 
    782778        else: 
    783779            self._properties["FontUnderline"] = val 
    …… 
    801797            v = self._headerFont 
    802798        except AttributeError: 
    803             v = self._getDefaultFont() 
    804             v.SetWeight(wx.BOLD) 
     799            v = self._headerFont = self._getDefaultFont() 
     800            v.Bold = True 
    805801        return v 
    806802     
    807803    def _setHeaderFont(self, val): 
    808804        if self._constructed(): 
     805            if not isinstance(val, dabo.ui.dFont): 
     806                # This will help make sure that any old-style font references 
     807                # are caught. 
     808                dabo.errorLog.write("Incorrect font type passed") 
     809                dabo.dBug.logPoint() 
     810                return 
    809811            self._headerFont = val 
    810812            self._refreshHeader() 
    …… 
    814816     
    815817    def _getHeaderFontBold(self): 
    816         return self.HeaderFont.GetWeight() == wx.BOLD 
     818        return self.HeaderFont.Bold 
    817819     
    818820    def _setHeaderFontBold(self, val): 
    819821        if self._constructed(): 
    820             font = self.HeaderFont 
    821             if val: 
    822                 font.SetWeight(wx.BOLD) 
    823             else: 
    824                 font.SetWeight(wx.LIGHT)    # wx.NORMAL doesn't seem to work... 
    825             self.HeaderFont = font 
     822            self.HeaderFont.Bold = val 
     823            self._refreshHeader() 
    826824        else: 
    827825            self._properties["HeaderFontBold"] = val 
    828826 
     827 
    829828    def _getHeaderFontDescription(self): 
    830         f = self.HeaderFont 
    831         ret = f.GetFaceName() + " " + str(f.GetPointSize()) 
    832         if f.GetWeight() == wx.BOLD: 
    833             ret += " B" 
    834         if f.GetStyle() == wx.ITALIC: 
    835             ret += " I" 
    836         return ret 
     829        return self.HeaderFont.Description 
     830 
    837831     
    838832    def _getHeaderFontInfo(self): 
    839         return self.HeaderFont.GetNativeFontInfoDesc() 
     833        return self.HeaderFont.NativeObject.GetNativeFontInfoDesc() 
    840834 
    841835         
    842836    def _getHeaderFontItalic(self): 
    843         return self.HeaderFont.GetStyle() == wx.ITALIC 
     837        return self.HeaderFont.Italic 
    844838     
    845839    def _setHeaderFontItalic(self, val): 
    846840        if self._constructed(): 
    847             font = self.HeaderFont 
    848             if val: 
    849                 font.SetStyle(wx.ITALIC) 
    850             else: 
    851                 font.SetStyle(wx.NORMAL) 
    852             self.HeaderFont = font 
     841            self.HeaderFont.Italic = val 
     842            self._refreshHeader() 
    853843        else: 
    854844            self._properties["HeaderFontItalic"] = val 
    …… 
    856846     
    857847    def _getHeaderFontFace(self): 
    858         return self.HeaderFont.GetFaceName() 
     848        return self.HeaderFont.Face 
    859849 
    860850    def _setHeaderFontFace(self, val): 
    861851        if self._constructed(): 
    862             f = self.HeaderFont 
    863             f.SetFaceName(val) 
    864             self.HeaderFont = f 
     852            self.HeaderFont.Face = val 
     853            self._refreshHeader() 
    865854        else: 
    866855            self._properties["HeaderFontFace"] = val 
    …… 
    868857     
    869858    def _getHeaderFontSize(self): 
    870         return self.HeaderFont.GetPointSize() 
     859        return self.HeaderFont.Size 
    871860     
    872861    def _setHeaderFontSize(self, val): 
    873862        if self._constructed(): 
    874             font = self.HeaderFont 
    875             font.SetPointSize(int(val)) 
    876             self.HeaderFont = font 
     863            self.HeaderFont.Size = val 
     864            self._refreshHeader() 
    877865        else: 
    878866            self._properties["HeaderFontSize"] = val 
    879867     
     868     
    880869    def _getHeaderFontUnderline(self): 
    881         return self.HeaderFont.GetUnderlined() 
     870        return self.HeaderFont.Underline 
    882871     
    883872    def _setHeaderFontUnderline(self, val): 
    884873        if self._constructed(): 
    885             # underlining doesn't seem to be working... 
    886             font = self.HeaderFont 
    887             font.SetUnderlined(bool(val)) 
    888             self.HeaderFont = font 
     874            self.HeaderFont.Underline = val 
     875            self._refreshHeader() 
    889876        else: 
    890877            self._properties["HeaderFontUnderline"] = val 
    …… 
    11781165 
    11791166    Font = property(_getFont, _setFont, None, 
    1180             _("The font properties of the column's cells. (obj)") ) 
     1167            _("The font properties of the column's cells. (dFont)") ) 
    11811168     
    11821169    FontBold = property(_getFontBold, _setFontBold, None, 
    …… 
    12081195 
    12091196    HeaderFont = property(_getHeaderFont, _setHeaderFont, None, 
    1210             _("The font properties of the column's header. (obj)") ) 
     1197            _("The font properties of the column's header. (dFont)") ) 
    12111198     
    12121199    HeaderFontBold = property(_getHeaderFontBold, _setHeaderFontBold, None, 
    …… 
    17671754                # Account for the width of the header caption: 
    17681755                cw = dabo.ui.fontMetricFromFont(colObj.Caption,  
    1769                         colObj.HeaderFont)[0] + capBuffer 
     1756                        colObj.HeaderFont.NativeObject)[0] + capBuffer 
    17701757                w = max(autoWidth, cw) 
    17711758                w = min(w, maxWidth) 
    …… 
    18251812 
    18261813            dc.SetTextForeground(fcolor) 
    1827             font = colObj.HeaderFont            
     1814            font = colObj.HeaderFont    .NativeObject 
    18281815 
    18291816            holdBrush = dc.GetBrush() 

  • trunk/dabo/ui/uiwx/dLabel.py

    r1593 r1788  
    1 import wx, dabo, dabo.ui 
     1import wx 
     2import dabo 
    23from dabo.dLocalize import _ 
    34 
    …… 
    78import dControlMixin as cm 
    89 
     10 
    911class dLabel(wx.StaticText, cm.dControlMixin): 
    10     """Creates a static label, to make a caption for another control, for example. 
    11     """ 
     12    """Creates a static label, to make a caption for another control, for example.""" 
    1213    def __init__(self, parent, properties=None, *args, **kwargs): 
    1314        self._baseClass = dLabel 
    1415        preClass = wx.PreStaticText 
    15         cm.dControlMixin.__init__(self, preClass, parent, properties, *args, **kwargs) 
    16  
    17  
    18     def _initEvents(self): 
    19         super(dLabel, self)._initEvents() 
     16        cm.dControlMixin.__init__(self, preClass, parent,  
     17                properties, *args, **kwargs) 
    2018 
    2119 
    …… 
    2321    def _getAutoResize(self): 
    2422        return not self._hasWindowStyleFlag(wx.ST_NO_AUTORESIZE) 
     23         
    2524    def _setAutoResize(self, value): 
    2625        self._delWindowStyleFlag(wx.ST_NO_AUTORESIZE) 
    2726        if not value: 
    2827            self._addWindowStyleFlag(wx.ST_NO_AUTORESIZE) 
     28 
    2929 
    3030    def _getAlignment(self): 
    …… 
    4141        self._delWindowStyleFlag(wx.ALIGN_CENTRE) 
    4242        self._delWindowStyleFlag(wx.ALIGN_RIGHT) 
    43  
    4443        value = str(value) 
    4544 
    …… 
    5352            raise ValueError, ("The only possible values are " 
    5453                            "'Left', 'Center', and 'Right'.") 
     54                             
    5555     
    5656    def _getFontBold(self): 
    5757        return super(dLabel, self)._getFontBold() 
     58         
    5859    def _setFontBold(self, val): 
    5960        super(dLabel, self)._setFontBold(val) 
    …… 
    6162            # This will force an auto-resize 
    6263            self.SetLabel(self.GetLabel()) 
     64             
    6365         
    6466    def _getFontFace(self): 
    6567        return super(dLabel, self)._getFontFace() 
     68         
    6669    def _setFontFace(self, val): 
    6770        super(dLabel, self)._setFontFace(val) 
    …… 
    6972            # This will force an auto-resize 
    7073            self.SetLabel(self.GetLabel()) 
     74             
    7175         
    7276    def _getFontItalic(self): 
    7377        return super(dLabel, self)._getFontItalic() 
     78         
    7479    def _setFontItalic(self, val): 
    7580        super(dLabel, self)._setFontItalic(val) 
    …… 
    7883            self.SetLabel(self.GetLabel()) 
    7984         
     85         
    8086    def _getFontSize(self): 
    8187        return super(dLabel, self)._getFontSize() 
     88         
    8289    def _setFontSize(self, val): 
    8390        super(dLabel, self)._setFontSize(val) 
    …… 
    93100            Center 
    94101            Right""") ) 
     102             
    95103    AutoResize = property(_getAutoResize, _setAutoResize, None, 
    96             _("Specifies whether the length of the caption determines " 
    97             "the size of the label. (bool)") ) 
     104            _("""Specifies whether the length of the caption determines 
     105            the size of the label. (bool)""") ) 
    98106     
    99107    FontBold = property(_getFontBold, _setFontBold, None, 
    100108            _("Sets the Bold of the Font (int)") ) 
     109             
    101110    FontFace = property(_getFontFace, _setFontFace, None, 
    102111            _("Sets the face of the Font (int)") ) 
     112             
    103113    FontItalic = property(_getFontItalic, _setFontItalic, None, 
    104114            _("Sets the Italic of the Font (int)") ) 
     115             
    105116    FontSize = property(_getFontSize, _setFontSize, None, 
    106117            _("Sets the size of the Font (int)") ) 
    …… 
    115126        self.Caption = "My God, it's full of stars!" 
    116127 
     128 
    117129if __name__ == "__main__": 
    118130    import test 

  • trunk/dabo/ui/uiwx/dPemMixin.py

    r1787 r1788  
    12521252    def _getFont(self): 
    12531253        ret = dabo.ui.dFont(Bold=self.FontBold,  
    1254                 Description=self.FontDescription, Face=self.FontFace, 
    1255                 Italic=self.FontItalic, Size=self.FontSize, 
    1256                 Underline=self.FontUnderline) 
    1257         ret._baseObject = self.GetFont() 
     1254                Face=self.FontFace, Italic=self.FontItalic,  
     1255                Size=self.FontSize, Underline=self.FontUnderline) 
    12581256        return ret 
    12591257     

  • trunk/dabo/ui/uiwx/dTreeView.py

    r1782 r1788  
    6161     
    6262 
     63    def _getCap(self): 
     64        if self.txt: 
     65            ret = self.txt 
     66        else: 
     67            ret = self.tree.GetItemText(self._id) 
     68        return ret 
     69         
     70    def _setCap(self, val): 
     71        self.txt = val 
     72        self.tree.SetItemText(self._id, val) 
     73     
     74     
     75    def _getChildren(self): 
     76        return self.tree.getChildren(self) 
     77 
     78 
     79    def _getDescendents(self): 
     80        return self.tree.getDescendents(self) 
     81 
     82 
    6383    def _getFont(self): 
    64         return self.tree.GetItemFont(self._id) 
     84        return dabo.ui.dFont(font=self.tree.GetItemFont(self._id)) 
    6585     
    6686    def _setFont(self, val): 
    67         assert isinstance(val, wx.Font) 
    68         self.tree.SetItemFont(self._id, val) 
     87        if not isinstance(val, dabo.ui.dFont): 
     88            # This will help make sure that any old-style font references 
     89            # are caught. 
     90            dabo.errorLog.write("Incorrect font type passed") 
     91            dabo.dBug.logPoint() 
     92            return 
     93        self.tree.SetItemFont(self._id, val.NativeObject) 
    6994 
    7095     
    7196    def _getFontBold(self): 
    72         return self.Font.GetWeight() == wx.BOLD 
     97        return self.tree.IsBold(self._id) 
    7398     
    7499    def _setFontBold(self, val): 
    75         font = self.Font 
    76         if val: 
    77             font.SetWeight(wx.BOLD) 
    78         else: 
    79             font.SetWeight(wx.LIGHT) 
    80         self.Font = font 
     100        self.tree.SetItemBold(self._id, val) 
     101 
    81102 
    82103    def _getFontDescription(self): 
    83         f = self.Font 
    84         ret = f.GetFaceName() + " " + str(f.GetPointSize()) 
    85         if f.GetWeight() == wx.BOLD: 
    86             ret += " B" 
    87         if f.GetStyle() == wx.ITALIC: 
    88             ret += " I" 
    89         return ret 
     104        return self.Font.Description 
     105 
    90106     
    91107    def _getFontInfo(self): 
    92         return self.Font.GetNativeFontInfoDesc() 
     108        return self.Font.NativeObject.GetNativeFontInfoDesc() 
    93109 
    94110         
    95111    def _getFontItalic(self): 
    96         return self.Font.GetStyle() == wx.ITALIC 
     112        return self.Font.Italic 
    97113     
    98114    def _setFontItalic(self, val): 
    99         font = self.Font 
    100         if val: 
    101             font.SetStyle(wx.ITALIC) 
    102         else: 
    103             font.SetStyle(wx.NORMAL) 
    104         self.Font = font 
     115        self.Font.Italic = val 
     116        self.tree.SetItemFont(self._id, self.Font.NativeObject) 
    105117 
    106118     
    107119    def _getFontFace(self): 
    108         return self.Font.GetFaceName() 
     120        return self.Font.Face 
    109121 
    110122    def _setFontFace(self, val): 
    111         f = self.Font 
    112         f.SetFaceName(val) 
    113         self.Font = f 
     123        self.Font.Face = val 
     124        self.tree.SetItemFont(self._id, self.Font.NativeObject) 
    114125 
    115126     
    116127    def _getFontSize(self): 
    117         return self.Font.GetPointSize() 
     128        return self.Font.Size 
    118129     
    119130    def _setFontSize(self, val): 
    120         font = self.Font 
    121         font.SetPointSize(int(val)) 
    122        self.Font = font 
     131        self.Font.Size = val 
     132        self.tree.SetItemFont(self._id, self.Font.NativeObject) 
     133     
    123134     
    124135    def _getFontUnderline(self): 
    125         return self.Font.GetUnderlined() 
     136        return self.Font.Underline 
    126137     
    127138    def _setFontUnderline(self, val): 
    128         # underlining doesn't seem to be working... 
    129         font = self.Font 
    130         font.SetUnderlined(bool(val)) 
    131         self.Font = font 
     139        self.Font.Underline = val 
     140        self.tree.SetItemFont(self._id, self.Font.NativeObject) 
    132141 
    133142 
    …… 
    136145 
    137146    def _setForeColor(self, val): 
    138  
    139147        if isinstance(val, basestring): 
    140148            try: 
    …… 
    143151        self.tree.SetItemTextColour(self._id, val) 
    144152     
     153     
    145154    def _getImg(self): 
    146155        return self.tree.getNodeImg(self) 
     156         
    147157    def _setImg(self, key): 
    148158        return self.tree.setNodeImg(self, key) 
    149159         
    150     def _getCap(self): 
    151         if self.txt: 
    152             ret = self.txt 
    153         else: 
    154             ret = self.tree.GetItemText(self._id) 
    155         return ret 
    156     def _setCap(self, val): 
    157         self.txt = val 
    158         self.tree.SetItemText(self._id, val) 
    159      
    160     def _getChildren(self): 
    161         return self.tree.getChildren(self) 
    162  
    163     def _getDescendents(self): 
    164         return self.tree.getDescendents(self) 
    165  
     160         
    166161    def _getSel(self): 
    167162        sel = self.tree.Selection 
    …… 
    171166            ret = (self == sel) 
    172167        return ret 
     168         
    173169    def _setSel(self, val): 
    174170        self.tree.SelectItem(self._id, val) 
     171         
    175172 
    176173    def _getSiblings(self):