def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
# Initialize factory provided level of detail settings:
self.lod = factory.facet_value( 'lod' )
self.maximum_lod = factory.facet_value( 'maximum_lod' )
self.is_vertical = (factory.orientation == 'vertical')
self.theme = factory.theme
# Initialize and create the underlying stacker control:
self.adapter = control = toolkit().create_scrolled_panel( parent )
stacker = toolkit().create_control( control, handle_keys = True )
control.content = self.stacker = stacker
# Initialize the StackContext object provided to each stack item:
self.context.facet_set(
graphics = stacker.temp_graphics,
control = stacker,
owner = self
)
# Initialize the various control event handlers:
control.set_event_handler(
size = self._size
)
stacker.set_event_handler(
paint = self._paint,
mouse = self._mouse,
key_press = self._key,
key = self._key
)
# Allow the editor to expand both horizontally and vertically:
control.size_policy = ( 'expanding', 'expanding' )
control.min_size = ( 40, 40 )
# Set up the additional 'list items changed' event handler needed for
# a list based facet:
self.context_object.on_facet_set(
self.update_editor_item, self.extended_name + '_items?',
dispatch = 'ui'
)
# Set up the item filter:
self.sync_value( factory.filter, 'filter', 'from' )
# Set up selection synchronization:
self.sync_value( factory.selected, 'selected', 'both' )
if factory.selected != '':
self.on_facet_set( self._selected_modified, 'items:selected' )
# Set up external change synchronization:
self.sync_value( factory.changed, 'changed', 'from' )
# Add the developer specified tooltip information:
self.set_tooltip()
def exception ( self, type, value, traceback,
msg = '', offset = 0, debug_frame = None ):
""" Handles a program exception or break point.
"""
# Get the correct status message and execution frames:
if value is None:
msg = msg or 'Called the FBI'
frames = [ StackFrame( frame )
for frame in stack( 15 )[ offset + 2: ] ]
else:
msg = 'Exception: %s' % str( value )
frames = [ StackFrame( frame )
for frame in getinnerframes( traceback, 15 ) ]
frames.reverse()
frames.extend( [ StackFrame( frame )
for frame in stack( 15 )[3:] ] )
# Make sure we don't handle and more exceptions for the moment:
self.enabled = False
# Set the new debugging context data:
self.msg = msg
self.frames = frames
self.debug_frame = debug_frame
# Activate the user interface containing all of the debugger tools:
self.tools.activate()
# Stop execution here until the developer resumes execution:
self.active = True
toolkit().event_loop()
self.active = False
# Resume execution and re-enable the debugger:
self.enabled = (not self.has_quit)
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
super( SimpleEditor, self ).init( parent )
factory = self.factory
if factory.evaluate is None:
self.adapter = control = toolkit().create_combobox( parent )
control.add_items( self.names )
control.set_event_handler( choose = self.update_object )
else:
self.adapter = control = toolkit().create_combobox( parent, True )
control.add_items( self.names )
control.set_event_handler(
choose = self.update_object,
text_enter = self.update_text_object,
lose_focus = self.on_kill_focus
)
if (not factory.is_grid_cell) and factory.auto_set:
control.set_event_handler(
text_change = self.update_text_object
)
self._no_enum_update = 0
self.set_tooltip()
def _create_image_grid ( self, parent ):
""" Populates a specified window with a grid of image buttons.
"""
# Create the panel to hold the ImageControl buttons:
self.adapter = adapter = toolkit().create_panel( parent )
# Create the layout manager:
layout = toolkit().create_grid_layout( -1, self.factory.cols )
# Add the set of all possible choices:
factory = self.factory
mapping = factory._mapping
cur_value = self.value
ics = []
for name in self.factory._names:
value = mapping[ name ]
ic = ImageControl(
image = '%s%s%s' % ( factory.prefix,
name, factory.suffix ),
selectable = True,
selected = (value == cur_value),
_value = value,
parent = adapter
)
ics.append( ic )
layout.add( ic(), left = 2, right = 2, top = 2, bottom = 2 )
self.set_tooltip( ic() )
self.image_controls = ics
# Finish setting up the layout manager:
adapter.layout = layout
adapter.shrink_wrap()
def rebuild_editor ( self ):
""" Rebuilds the contents of the editor whenever the original factory
object's **values** facet changes.
"""
# Clear any existing content:
panel = self.adapter
layout = panel.layout
if layout is not None:
layout.clear()
# Get the current facet value:
cur_name = self.str_value
# Create a sizer to manage the radio buttons:
names = self.names
mapping = self.mapping
n = len( names )
cols = self.factory.cols
rows = ( n + cols - 1 ) / cols
incr = [ n / cols ] * cols
rem = n % cols
for i in range( cols ):
incr[i] += (rem > i)
incr[-1] = -(reduce( lambda x, y: x + y, incr[:-1], 0 ) - 1)
if cols > 1:
layout = toolkit().create_grid_layout( 0, cols, 2, 4 )
else:
layout = toolkit().create_box_layout()
# Add the set of all possible choices:
### style = wx.RB_GROUP
index = 0
for i in range( rows ):
for j in range( cols ):
if n > 0:
name = label = names[ index ]
label = self.string_value( label, capitalize )
control = toolkit().create_radio_button( panel, label )
### control = wx.RadioButton( panel, -1, label, style = style )
control._value = mapping[ name ]
### style = 0
control.checked = (name == cur_name)
control.set_event_handler( dialed = self.update_object )
self.set_tooltip( control )
index += incr[j]
n -= 1
else:
control = toolkit().create_radio_button( panel )
control._value = ''
control.visible = False
layout.add( control, top = 5, fill = False )
# Set-up the layout:
panel.layout = layout
panel.shrink_wrap()
def error ( self, excp ):
""" Handles an error that occurs while setting the object's facet value.
"""
self._text.background_color = ErrorColor
self._text.refresh()
toolkit().beep()
if self._error is None:
self._error = True
self.ui.errors += 1
def exit_ui ( self ):
""" Exits the user interface.
"""
# Release no longer needed data being held by the debugger:
self.debug_frame = None
self.frames = []
self.local_variables = []
self.frame_locals = {}
# Terminate the debugger's event loop and allow the program to resume
# execution:
toolkit().event_loop( 0 )
def __init__ ( self, dock_control, use_mouse = False, **facets ):
""" Initializes the object.
"""
super( DockWindowShell, self ).__init__( **facets )
control = dock_control.control
self.control = shell = toolkit().create_frame( control.root_parent(),
shell_style, dock_control.name )
shell.icon = FrameIcon
shell.background_color = WindowColor
shell.set_event_handler( close = self._on_close )
theme = dock_control.theme
self.dock_window = dw = DockWindow(
shell,
auto_close = True,
theme = theme ).set(
style = 'tab'
)
shell.layout = layout = toolkit().create_box_layout()
layout.add( dw.control, stretch = 1, fill = True )
if use_mouse:
x, y = shell.mouse_position
else:
x, y = dock_control.control.screen_position
dx, dy = control.size
tis = theme.tab.image_slice
tc = theme.tab.content
tdy = theme.tab_active.image_slice.dy
dx += (tis.xleft + tc.left + tis.xright + tc.right)
dy += (tis.xtop + tc.top + tis.xbottom + tc.bottom + tdy)
self.add_control( dock_control )
# Set the correct window size and position, accounting for the tab size
# and window borders:
shell.bounds = ( x, y, dx, dy )
cdx, cdy = shell.client_size
ex_dx = dx - cdx
ex_dy = dy - cdy
shell.bounds = ( x - (ex_dx / 2) - tis.xleft - tc.left,
y - ex_dy + (ex_dx / 2) - tdy - tis.xtop - tc.top,
dx + ex_dx, dy + ex_dy )
shell.visible = True
def _pop_up_text ( self ):
""" Pop-up a text control to allow the user to enter a value using
the keyboard.
"""
control = self.adapter
factory = self.factory
self._text = text = toolkit().create_text_input( control(),
password = factory.password,
handle_enter = True,
align = self.alignment )
text.value = self.str_value
slice = self.image_slice
wdx, wdy = control.client_size
tdx, tdy = text.size
text.bounds = ( slice.xleft,
((wdy + slice.xtop - slice.xbottom - tdy) / 2) + 1,
wdx - slice.xleft - slice.xright,
tdy )
text.selection = ( -1, -1 )
text.set_focus()
text.set_event_handler(
lose_focus = self._text_completed,
key = self._key_entered,
text_enter = self.update_object
)
if factory.auto_set and (not factory.is_grid_cell):
text.set_event_handler( text_change = self.update_object )
def create_editor ( self, parent ):
""" Creates the editor control (a button).
"""
self._button = button = toolkit().create_button( parent )
button.set_event_handler( clicked = self.edit_instance )
return button
def _layout_set ( self, layout ):
""" Handles the 'layout' facet being changed.
"""
if layout is None:
self.control.layout = None
else:
self.control.layout = toolkit().layout_adapter_for( layout )
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
if WebView is not None:
from PyQt4.QtWebKit import QWebPage
self.control = control = WebView( parent, self )
factory = self.factory
self.sync_value( factory.title, 'title', 'to' )
control.connect( control, SIGNAL( 'titleChanged(QString)' ),
self._on_title_modified )
url = factory.url
alt_url = factory.alt_url
if (url != '') or (alt_url != ''):
self.sync_value( url, 'url', 'to' )
self.sync_value( alt_url, 'alt_url', 'to' )
control.page().setLinkDelegationPolicy(
QWebPage.DelegateAllLinks )
control.connect( control, SIGNAL( 'linkClicked(QUrl)' ),
self._on_link_clicked )
else:
self.renders_html = False
self.adapter = toolkit().create_text_input( parent,
read_only = True, multi_line = True )
self.set_tooltip()
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
# Create the control:
self.adapter = control = toolkit().create_control( parent )
control.min_size = ( 150, 150 )
# Set up the event handlers:
control.set_event_handler(
paint = self._paint,
left_down = self._left_down,
left_dclick = self._left_dclick,
left_up = self._left_up,
middle_down = self._middle_down,
middle_up = self._middle_up,
right_down = self._right_down,
right_up = self._right_up,
motion = self._motion,
wheel = self._mouse_wheel,
size = self._size
)
if self.factory.allow_drop:
control.drop_target = self
self.sync_value( self.factory.selected, 'selected', 'both' )
# Set the tooltip:
self.set_tooltip()
def create_control ( self ):
""" Creates and returns the underlying toolkit neutral control used to
implement the window.
"""
control = toolkit().create_control( self.parent,
tab_stop = self.tab_stop,
handle_keys = self.handle_keys
)
control.set_event_handler(
paint = self._paint,
size = self.resize,
left_down = self._left_down,
left_up = self._left_up,
left_dclick = self._left_dclick,
middle_down = self._middle_down,
middle_up = self._middle_up,
middle_dclick = self._middle_dclick,
right_down = self._right_down,
right_up = self._right_up,
right_dclick = self._right_dclick,
motion = self._motion,
enter = self._enter,
leave = self._leave,
wheel = self._wheel
)
control.drop_target = self
return control
def __getstate__ ( self ):
ftc = toolkit().from_toolkit_color
return {
'image': None if self.image is None else str( self.image ),
'bg_color': ftc( self.bg_color ),
'text_color': ftc( self.text_color ),
'lfdx': self.lfdx,
'mfdx': self.mfdx,
'rfdx': self.rfdx,
'sdx': self.sdx,
'tfdy': self.tfdy,
'mfdy': self.mfdy,
'bfdy': self.bfdy,
'sdy': self.sdy,
'lfx': self.lfx,
'mfx': self.mfx,
'rfx': self.rfx,
'tfy': self.tfy,
'mfy': self.mfy,
'bfy': self.bfy,
'hsx': self.hsx,
'vsy': self.vsy,
'lcdx': self.lcdx,
'rcdx': self.rcdx,
'tcdy': self.tcdy,
'bcdy': self.bcdy
}
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
self.evaluate = factory.evaluate
self.sync_value( factory.evaluate_name, 'evaluate', 'from' )
multi_line = self.multi_line
if (not factory.multi_line) or factory.password:
multi_line = False
self.scrollable = multi_line
self._handle_enter = (factory.enter_set and (not multi_line))
self.adapter = adapter = toolkit().create_text_input( parent,
password = factory.password,
handle_enter = self._handle_enter,
multi_line = multi_line )
adapter.value = self.str_value
adapter.set_event_handler( lose_focus = self.update_object )
if self._handle_enter:
adapter.set_event_handler( text_enter = self.update_object )
if not factory.auto_set:
adapter.set_event_handler( text_change = self.check_update )
if factory.auto_set:
adapter.set_event_handler( text_change = self.update_object )
self.set_tooltip()
def __init__ ( self, name = '', search_path = None, bitmap = None,
width = None, height = None, **facets ):
""" Initializes the object.
"""
self.name = name
if (width is not None) and (height is not None) and (bitmap is None):
from facets.api import toolkit
bits = '\x00' * (width * height * 4)
bitmap = toolkit().create_bitmap( bits, width, height )
bitmap._bits = bits
if bitmap is not None:
self.bitmap = bitmap
if search_path is not None:
self.search_path = search_path
else:
search_path, name = split( name )
if search_path != '':
self.name = name
self.search_path = [ search_path ]
else:
self.search_path = [ resource_path() ]
super( MImageResource, self ).__init__( **facets )
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
# Make sure the slider and track image slices have been initialized:
self._factory_tip_style_modified()
self._factory_body_style_modified()
self._factory_track_style_modified()
# Create the control:
self.adapter = control = toolkit().create_control(
parent, tab_stop = self.factory.tab_stop
)
control.min_size = ( 100, 19 )
# Set up the event handlers:
control.set_event_handler(
paint = self._paint,
get_focus = self._set_focus,
left_down = self._left_down,
left_up = self._left_up,
motion = self._motion,
wheel = self._mouse_wheel,
enter = self._enter_window,
leave = self._leave_window,
size = self._resize
)
# Initialize widest tip size seen so far:
self._tsz = 0
# Set the tooltip:
self.has_tooltip = self.set_tooltip()
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
super( RadioEditor, self ).init( parent )
# Create a panel to hold all of the radio buttons:
self.adapter = toolkit().create_panel( parent )
self.rebuild_editor()
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
# Establish the range of the slider:
low, high, increment = factory.low, factory.high, factory.increment
if high <= low:
low = high = None
range = self.object.facet( self.name ).handler
if isinstance( range, Range ):
low, high = range._low, range._high
if low is None:
if high is None:
high = 1.0
low = high - 1.0
elif high is None:
high = low + 1.0
# Establish the slider increment:
if increment <= 0.0:
if isinstance( low, int ):
increment = 1.0
else:
increment = pow( 10, int( log10( ( high - low ) / 1000.0 ) ) )
# Save the values we calculated:
self.set( low = low, high = high, increment = increment )
# Synchronize with any dynamically specified range values:
self.sync_value( factory.low_name, 'low', 'from' )
self.sync_value( factory.high_name, 'high', 'from' )
self.sync_value( factory.increment_name, 'increment', 'from' )
# Create the control:
self.adapter = control = toolkit().create_control( parent,
tab_stop = True )
control.min_size = ( 30, 20 )
# Set up the event handlers:
control.set_event_handler(
paint = self._on_paint,
get_focus = self._set_focus,
left_down = self._left_down,
left_up = self._left_up,
motion = self._motion,
wheel = self._mouse_wheel,
enter = self._enter_window,
leave = self._leave_window,
size = self._resize
)
# Set the tooltip:
if not self.set_tooltip():
self._set_tooltip()
def _rgba_color ( self, color ):
""" Returns a standard (r,g,b,a) tuple representation of the specified
GUI toolkit specific color.
"""
result = toolkit().from_toolkit_color( color )
if len( result ) == 4:
return result
return (result + ( 255, ))
def __init__ ( self, parent, **facets ):
""" Creates a new image control.
"""
super( ImageButton, self ).__init__( **facets )
# Calculate the size of the button:
idx = idy = tdx = tdy = 0
image = self.image
if image is not None:
idx, idy, size = image.width, image.height, self.image_size
if size > 0:
idx_dy = max( idx, idy )
if size != idx_dy:
self.image = image = image.scale( size / float( idx_dy ) )
idx, idy = image.width, image.height
self.control = control = toolkit().create_control( parent )
if self.label != '':
tdx, tdy = control.text_size( self.label )
wp2 = self.width_padding + 2
hp2 = self.height_padding + 2
if self.orientation == 'horizontal':
self._ix = wp2
spacing = (idx > 0) * (tdx > 0) * 4
self._tx = self._ix + idx + spacing
dx = idx + tdx + spacing
dy = max( idy, tdy )
self._iy = hp2 + ((dy - idy) / 2)
self._ty = hp2 + ((dy - tdy) / 2)
else:
self._iy = hp2
spacing = (idy > 0) * (tdy > 0) * 2
self._ty = self._iy + idy + spacing
dx = max( idx, tdx )
dy = idy + tdy + spacing
self._ix = wp2 + ((dx - idx) / 2)
self._tx = wp2 + ((dx - tdx) / 2)
# Finish initializing the control:
self._dx = dx + wp2 + wp2
self._dy = dy + hp2 + hp2
control.size = control.min_size = ( self._dx, self._dy )
self.control._owner = self
self._mouse_over = self._button_down = False
# Set up mouse event handlers:
control.set_event_handler(
enter = self._on_enter_window,
leave = self._on_leave_window,
left_down = self._on_left_down,
left_up = self._on_left_up,
paint = self._on_paint
)
def key_ctrl_c ( self, event ):
""" Copy this item to the clipboard.
The [[Ctrl-c]] command copies the item, including all textual
annotations such as item ids and line numbers, to the clipboard.
You can use the [[c]] command to copy the item without any
annotations to the clipboard.
"""
toolkit().clipboard().text = remove_color( self.text )
def copy_clipboard ( self ):
""" Copy the item to the clipboard.
The [[c]] command copies the item, without any textual annotations
such as item ids and line numbers, to the clipboard.
You can use the [[Ctrl-c]] command to copy the item including all
textual annotations to the clipboard.
"""
toolkit().clipboard().text = remove_color( self.str( self.item ) )
def str_color(self, color):
""" Returns the text representation of a specified color value.
"""
if isinstance(color, basestring):
return color
color = toolkit().from_toolkit_color(color)
if (len(color) < 4) or (color[3] == 255):
return "(%d,%d,%d)" % color[:3]
return "(%d,%d,%d,%d)" % color
def add ( self, item ):
""" Adds an adapted item to the layout.
"""
# We only need to do something here if the item being added is another
# layout, since we only expect to have concrete controls as children.
# So we create a panel and set its layout to the one we were given, and
# so we will have the new panel as our child to layout:
if isinstance( item, Layout ):
toolkit().create_panel( self.image_panel.control ).layout = item
#-- EOF ------------------------------------------------------------------------
def __str__ ( self ):
""" Returns the string respresentation of the image slice.
"""
ftc = toolkit().from_toolkit_color
return ImageSliceTemplate % (
self.image, ftc( self.bg_color ), ftc( self.text_color ), self.lfdx,
self.mfdx, self.rfdx, self.sdx, self.tfdy, self.mfdy, self.bfdy,
self.sdy, self.lfx, self.mfx, self.rfx, self.tfy, self.mfy,
self.bfy, self.hsx, self.vsy, self.lcdx, self.rcdx, self.tcdy,
self.bcdy
)
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
self.adapter = control = toolkit().create_control( parent )
control.set(
size = ( 1, 1 ),
background_color = control.parent.background_color,
size_policy = ( 'expanding', 'expanding' )
)
control.set_event_handler( paint = self._on_paint )
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
super( ListEditor, self ).init( parent )
# Create a panel to hold all of the radio buttons:
self.adapter = control = toolkit().create_listbox( parent )
control.add_items( self.names )
control.set_event_handler( selected = self.update_object )
self.set_tooltip()
def set_color(editor):
""" Sets the color of the specified color control.
"""
color = editor.factory.to_toolkit_color(editor)
control = editor.adapter
control.background_color = color
color = toolkit().from_toolkit_color(color)
if (color[0] > 192) or (color[1] > 192) or (color[2] > 192):
control.foreground_color = Black
else:
control.foreground_color = White
control.refresh()