def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
self.adapter = toolkit().create_text_input( parent, read_only = True )
self.adapter.background_color = ReadonlyColor
self.set_tooltip()
def __init__ ( self, parent, *args, **kw ):
""" Creates a wx.Panel that correctly sets its background color to be
the same as its parents.
"""
from facets.extra.helper.debug import created_from; created_from( self )
wx.Panel.__init__( self, parent, *args, **kw )
wx.EVT_CHILD_FOCUS( self, self.OnChildFocus )
wx.EVT_ERASE_BACKGROUND( self, self.OnEraseBackground )
wx.EVT_PAINT( self, self.OnPaint )
self.SetBackgroundColour( parent.GetBackgroundColour() )
# Make sure that we have an associated GUI toolkit neutral adapter
# defined so we don't have to check in the paint handler each time:
toolkit().control_adapter_for( self )
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
self.adapter = toolkit().create_checkbox( parent )
self.adapter.set_event_handler( checked = self.update_object )
self.set_tooltip()
def dockable_get_control ( self, parent ):
""" Gets a control that can be docked into a DockWindow.
"""
print "The 'IDockable.dockable_get_control' method must be overridden"
panel = toolkit().create_panel( parent )
panel.background_color = 0xFF0000
return panel()
def show ( self ):
""" Shows the feature bar.
"""
# Make sure all prerequisites are met:
dock_control, parent = self.dock_control, self.parent
if (dock_control is None) or (parent is None):
return
# Create the actual control (if needed):
control = self.control
if control is None:
self.control = control = toolkit().create_frame( parent,
feature_bar_style )
# Set up all of the event handlers:
control.set_event_handler(
paint = self.paint,
left_down = self.left_down,
left_up = self.left_up,
right_down = self.right_down,
right_up = self.right_up,
motion = self.mouse_move,
enter = self.mouse_enter
)
# Set up to handle drag and drop events:
control.drop_target = self
# Calculate the best size and position for the feature bar:
size = ( 32, 32 )
width = height = 0
horizontal = self.horizontal
self.features = [ feature
for feature in dock_control.active_features
if feature.is_enabled() and (feature.bitmap is not None)
]
for feature in self.features:
bitmap = feature.bitmap
dx, dy = control.bitmap_size( bitmap )
if horizontal:
width += (dx + 3)
height = max( height, dy )
else:
width = max( width, dx )
height += (dy + 3)
if width > 0:
if horizontal:
width += 5
height += 8
else:
width += 8
height += 5
px, py = parent.screen_position
fx, fy = dock_control.feature_popup_position
control.bounds = ( px + fx, py + fy, width, height )
control.visible = True
def init ( self, parent ):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
label = self.factory.label or self.item.get_label( self.ui )
self.adapter = toolkit().create_button( parent,
self.string_value( label ) )
self.adapter.set_event_handler( clicked = self.update_object )
self.sync_value( self.factory.label_value, 'label', 'from' )
self.set_tooltip()
def _height_default(self):
if self.volume is None:
return 0
image = self.volume.image_resource(self.image_name)
if image is None:
self.width = 0
return 0
self.width, height = toolkit().image_size(image.create_image())
return height
def create_control ( self, parent ):
""" Creates the underlying window used for the notebook.
"""
# Create the correct type of window based on whether or not it should
# be scrollable:
root = parent
if self.scrollable:
root = toolkit().create_scrolled_panel( parent )
self.control = control = toolkit().create_panel( root )
control._image_slice = getattr( parent, '_image_slice', None )
self.layout = VerticalNotebookLayout( notebook = self )
# Set up the painting event handler:
control.set_event_handler( paint = self._paint )
if root is parent:
return control
root.content = control
return root
def _get_screen_graphics ( self ):
from facets.ui.toolkit import toolkit
if self._screen_graphics is None:
control = self.control
pixmap = QPixmap.grabWindow( control.winId() )
self._sg_control = sg = toolkit().create_control( self )
sg._pixmap = pixmap
dx, dy = self.size
sg.bounds = ( 0, 0, dx, dy )
sg.set_event_handler( paint = self._screen_graphics_paint )
painter = painter_for( pixmap )
painter._control = sg.control
self._screen_graphics = (
QtGraphics( painter, bitmap = pixmap ), 0, 0
)
return self._screen_graphics
def wdump ( control, msg = '', root = True ):
""" Dumps a GUI toolkit neutral control hierarchy to standard out.
"""
from facets.ui.toolkit import toolkit
control = toolkit().as_toolkit_adapter( control )
if root:
parent = control.parent
while parent is not None:
control = parent
parent = control.parent
if msg == '':
msg = stack( 1 )[1][3]
print '--- %s %s' % ( msg, '-' * (74 - len( msg )) )
_wdump( control, 0, '' )
def edit_facets ( self, view = None, parent = None, kind = None,
context = None, handler = None, id = '',
scrollable = None, **args ):
""" Edits the object's facets.
"""
if context is None:
context = self
if handler is None:
handler = self
view = self.facet_view( view )
from facets.ui.toolkit import toolkit
from facets.ui.view_application import view_application
if toolkit().is_application_running():
return view.ui( context, parent, kind, self.facet_view_elements(),
handler, id, scrollable, args )
return view_application( context, view, kind, handler, id, scrollable,
args )
def _fonts_matching ( self, match_value ):
""" Returns a list of all font names whose fixed versus proportional
type is the same as *match_value* (a boolean).
"""
font_cache = self.facet_db_get( 'font_db', {} )
cache_modified = False
matching_fonts = []
font_fixed = toolkit().font_fixed
for font in self.fonts:
is_fixed = font_cache.get( font, None )
if is_fixed is None:
font_cache[ font ] = is_fixed = font_fixed( font )
cache_modified = True
if is_fixed == match_value:
matching_fonts.append( font )
if cache_modified:
self.facet_db_set( 'font_db', font_cache )
matching_fonts.sort()
return matching_fonts
def normalized_color ( color, has_alpha = False, as_int = True ):
""" Returns the value of *color* as a normalized color tuple of the form:
( red, green, blue [, alpha] ), where reg, green, blue and alpha are
integers in the range 0..255 if *as_int* is True and are floats in the
range 0.0..1.0 otherwise. If *has_alpha* is True, the result will have
four elements; otherwise it will have three.
The *color* value can be:
- a 'web' color string of the form: '#rgb' or '#rrggbb'.
- an integer value of the form: 0xAARRGGBB.
- a tuple or list of the form: ( hue, level, saturation [, alpha] )
representing an HLS(A) encoded color, where hue is an integer value in
the range 0..359, and level, saturation and alpa are float values in
the range 0.0..1.0.
- a tuple or list of the form: ( red, green, blue [, alpha] ), where
red, green, blue and alpha can all be integer values in the range
0..255, or float values in the range 0.0..1.0.
- a GUI toolkit specific color object.
Any input value not matching this description will cause a FacetError to
be raised.
"""
# Handle case of 'web' color of the form: '#rgb' or '#rrggbb':
if isinstance( color, basestring ) and color.startswith( '#' ):
code = color[1:]
if len( code ) == 3:
r, g, b = code
code = '%s%s%s%s%s%s' % ( r, r, g, g, b, b )
if len( code ) == 6:
try:
color = int( code, 16 )
except:
pass
# Initialize the component types (True = int, False = float):
r = g = b = a = True
if isinstance( color, IntegerTypes ):
alpha = 255 - int( (color >> 24) & 0xFF )
red = int( (color >> 16) & 0xFF )
green = int( (color >> 8) & 0xFF )
blue = int( color & 0xFF )
elif isinstance( color, SequenceTypes ) and (3 <= len( color ) <= 4):
def color_component ( color, index, upper = 255 ):
value = color[ index ] if index < len( color ) else 255
if isinstance( value, IntegerTypes ):
if 0 <= value <= upper:
return ( True, value )
elif isinstance( value, float ) and (0.0 <= value <= 1.0):
return ( False, value )
raise FacetError
a, alpha = color_component( color, 3 )
if (isinstance( color[0], IntegerTypes ) and
isinstance( color[1], float ) and
isinstance( color[2], float )):
# Handle an HLS(A) encoded tuple, which has the form:
# ( int, float, float [, float ] ):
from colorsys import hls_to_rgb
r = g = b = False
red, green, blue = hls_to_rgb(
color_component( color, 0, 359 )[1] / 360.0,
color_component( color, 1 )[1],
color_component( color, 2 )[1]
)
else:
r, red = color_component( color, 0 )
g, green = color_component( color, 1 )
b, blue = color_component( color, 2 )
else:
from facets.ui.toolkit import toolkit
try:
value = toolkit().from_toolkit_color( color )
if len( value ) == 3:
red, green, blue = value
alpha = 255
else:
red, green, blue, alpha = value
except:
raise FacetError
if as_int:
if not r: red = int( 255.0 * red )
if not g: green = int( 255.0 * green )
if not b: blue = int( 255.0 * blue )
if not a: alpha = int( 255.0 * alpha )
else:
if r: red /= 255.0
if g: green /= 255.0
if b: blue /= 255.0
if a: alpha /= 255.0
return (( red, green, blue, alpha ) if has_alpha else ( red, green, blue ))
def _fonts_default ( self ):
names = toolkit().font_names()
names.sort()
return names
def _layout_set ( self, layout ):
""" Handles the 'layout' facet being changed by linking the
underlying toolkit specific control and layout objects together.
"""
self.control.layout = toolkit().layout_adapter_for( layout )