import tk
from enthought.traits.api import Trait, TraitHandler, TraitError, TraitFactory
from editor_factory import EditorFactory, SimpleEditor, TextEditor, \
ReadonlyEditor
from editor import Editor
from helper import choice_width
PointSizes = [
'8', '9', '10', '11', '12', '14', '16', '18',
'20', '22', '24', '26', '28', '36', '48', '72'
]
facenames = None
class ToolkitEditorFactory ( EditorFactory ):
def simple_editor ( self, ui, object, name, description, parent ):
return SimpleFontEditor( parent,
factory = self,
ui = ui,
object = object,
name = name,
description = description )
def custom_editor ( self, ui, object, name, description, parent ):
return CustomFontEditor( parent,
factory = self,
ui = ui,
object = object,
name = name,
description = description )
def text_editor ( self, ui, object, name, description, parent ):
return TextFontEditor( parent,
factory = self,
ui = ui,
object = object,
name = name,
description = description )
def readonly_editor ( self, ui, object, name, description, parent ):
return ReadonlyFontEditor( parent,
factory = self,
ui = ui,
object = object,
name = name,
description = description )
def to_wx_font ( self, editor ):
""" Returns a wxFont object corresponding to a specified object's font
trait.
"""
font = editor.value
return wx.Font( font.GetPointSize(), font.GetFamily(), font.GetStyle(),
font.GetWeight(), font.GetUnderlined(),
font.GetFaceName() )
def from_wx_font ( self, font ):
""" Gets the application equivalent of a Tkinter Font value.
"""
return font
def str_font ( self, font ):
""" Returns the text representation of the specified object trait value.
"""
weight = { wx.LIGHT: ' Light',
wx.BOLD: ' Bold' }.get( font.GetWeight(), '' )
style = { wx.SLANT: ' Slant',
wx.ITALIC:' Italic' }.get( font.GetStyle(), '' )
return '%s point %s%s%s' % (
font.GetPointSize(), font.GetFaceName(), style, weight )
class SimpleFontEditor ( SimpleEditor ):
def popup_editor ( self, event ):
""" Invokes the pop-up editor for an object trait.
"""
font_data = wx.FontData()
font_data.SetInitialFont( self.factory.to_wx_font( self ) )
dialog = wx.FontDialog( self.control, font_data )
if dialog.ShowModal() == wx.ID_OK:
self.value = self.factory.from_wx_font(
dialog.GetFontData().GetChosenFont() )
dialog.Destroy()
def update_editor ( self ):
""" Updates the editor when the object trait changes external to the
editor.
"""
super( SimpleFontEditor, self ).update_editor()
set_font( self )
def string_value ( self, font ):
""" Returns the text representation of a specified font value.
"""
return self.factory.str_font( font )
class CustomFontEditor ( Editor ):
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
self.control = panel = wx.Panel( parent, -1 )
sizer = wx.BoxSizer( wx.VERTICAL )
font = self._font = wx.TextCtrl( panel, -1, self.str_value )
wx.EVT_KILL_FOCUS( font, self.update_object )
wx.EVT_TEXT_ENTER( panel, font.GetId(), self.update_object )
sizer.Add( font, 0, wx.EXPAND | wx.BOTTOM, 3 )
sizer2 = wx.BoxSizer( wx.HORIZONTAL )
facenames = all_facenames()
control = self._facename = wx.Choice( panel, -1, wx.Point( 0, 0 ),
wx.Size( choice_width( facenames ), 20 ),
facenames )
sizer2.Add( control, 2, wx.EXPAND )
wx.EVT_CHOICE( panel, control.GetId(), self.update_object_parts )
control = self._point_size = wx.Choice( panel, -1,
wx.Point( 0, 0 ), wx.Size( 30, 20 ),
PointSizes )
sizer2.Add( control, 1, wx.EXPAND | wx.RIGHT, 3 )
wx.EVT_CHOICE( panel, control.GetId(), self.update_object_parts )
sizer.Add( sizer2, 0, wx.EXPAND )
panel.SetAutoLayout( True )
panel.SetSizer( sizer )
sizer.Fit( panel )
def update_object ( self, event ):
""" Handles the user changing the contents of the font text control.
"""
self.value = self._font.GetValue()
def update_object_parts ( self, event ):
""" Handles the user modifying one of the font components.
"""
point_size = int( self._point_size.GetStringSelection() )
facename = self._facename.GetStringSelection()
font = wx.Font( point_size, wx.DEFAULT, wx.NORMAL, wx.NORMAL,
faceName = facename )
self.value = self.factory.from_wx_font( font )
def update_editor ( self ):
""" Updates the editor when the object trait changes external to the
editor.
"""
font = self.factory.to_wx_font( self )
try:
self._facename.SetStringSelection( font.GetFaceName() )
except:
self._facename.SetSelection( 0 )
try:
self._point_size.SetStringSelection( str( font.GetPointSize() ) )
except:
self._point_size.SetSelection( 0 )
font.SetPointSize( min( 10, font.GetPointSize() ) )
self._font.SetValue( self.str_value )
self._font.SetFont( font )
def string_value ( self, font ):
""" Returns the text representation of a specified font value.
"""
return self.factory.str_font( font )
class TextFontEditor ( TextEditor ):
def update_object ( self, event ):
""" Handles the user changing the contents of the edit control.
"""
self.value = self.control.GetValue()
def update_editor ( self ):
""" Updates the editor when the object trait changes external to the
editor.
"""
super( TextFontEditor, self ).update_editor()
set_font( self )
def string_value ( self, font ):
""" Returns the text representation of a specified font value.
"""
return self.factory.str_font( font )
class ReadonlyFontEditor ( ReadonlyEditor ):
def update_editor ( self ):
""" Updates the editor when the object trait changes external to the
editor.
"""
super( ReadonlyFontEditor, self ).update_editor()
set_font( self )
def string_value ( self, font ):
""" Returns the text representation of a specified font value.
"""
return self.factory.str_font( font )
def set_font ( editor ):
font = editor.factory.to_wx_font( editor )
font.SetPointSize( min( 10, font.GetPointSize() ) )
editor.control.SetFont( font )
def all_facenames ( ):
""" Returns a list of all available font facenames.
"""
global facenames
if facenames is None:
facenames = FontEnumerator().facenames()
facenames.sort()
return facenames
class FontEnumerator ( wx.FontEnumerator ):
def facenames ( self ):
""" Returns a list of all available font facenames.
"""
self._facenames = []
self.EnumerateFacenames()
return self._facenames
def OnFacename ( self, facename ):
""" Adds a facename to the list of facenames.
"""
self._facenames.append( facename )
return True
font_families = {
'default': wx.DEFAULT,
'decorative': wx.DECORATIVE,
'roman': wx.ROMAN,
'script': wx.SCRIPT,
'swiss': wx.SWISS,
'modern': wx.MODERN
}
font_styles = {
'slant': wx.SLANT,
'italic': wx.ITALIC
}
font_weights = {
'light': wx.LIGHT,
'bold': wx.BOLD
}
font_noise = [ 'pt', 'point', 'family' ]
class TraitWXFont ( TraitHandler ):
def validate ( self, object, name, value ):
""" Validates that the value is a valid font.
"""
if isinstance( value, wx.FontPtr ):
return wx.Font( value.GetPointSize(), value.GetFamily(),
value.GetStyle(), value.GetWeight(),
value.GetUnderlined(), value.GetFaceName() )
if isinstance( value, wx.Font ):
return value
try:
point_size = 10
family = wx.DEFAULT
style = wx.NORMAL
weight = wx.NORMAL
underline = 0
facename = []
for word in value.split():
lword = word.lower()
if font_families.has_key( lword ):
family = font_families[ lword ]
elif font_styles.has_key( lword ):
style = font_styles[ lword ]
elif font_weights.has_key( lword ):
weight = font_weights[ lword ]
elif lword == 'underline':
underline = 1
elif lword not in font_noise:
try:
point_size = int( lword )
except:
facename.append( word )
return wx.Font( point_size, family, style, weight, underline,
' '.join( facename ) )
except:
pass
raise TraitError, ( object, name, 'a font descriptor string',
repr( value ) )
def info ( self ):
return ( "a string describing a font (e.g. '12 pt bold italic "
"swiss family Arial' or 'default 12')" )
fh = TraitWXFont()
font_trait = Trait( fh.validate( None, None, 'Arial 10' ), fh,
editor = ToolkitEditorFactory() )
def TkFont ( value = 'Arial 10', **metadata ):
return Trait( value, font_trait, **metadata )
TkFont = TraitFactory( TkFont )