# $Id: BaseWidget.py,v 1.61.2.15 2007/02/23 20:52:49 marcusva Exp $ # # Copyright (c) 2004-2007, Marcus von Appen # All rights reserved. # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. """Basic widget class, used as an abstract definition for widgets.""" # TODO: Add ControlCollection class to the components. from pygame import sprite, Rect, Surface from pygame import error as PygameError from ocempgui.object import BaseObject from ocempgui.access import IIndexable from Style import WidgetStyle from Constants import * import base class BaseWidget (BaseObject, sprite.Sprite): """BaseWidget () -> BaseWidget A basic widget class for user interface elements. The BaseWidget is the most basic widget class, from which any other widget class should be inherited. It provides the most basic attributes and methods, every widget needs. The widget is a visible (or non-vissible) element on the display, which allows the user to interact with it (active or passive) in a specific way. It has several methods and attributes to allow developers to control this interaction and supports accessibility through the ocempgui.access module. The widget can be placed on the display by accessing the various attributes of its 'rect' attribute directly. It exposes the following pygame.Rect attributes: top, left, bottom, right, topleft, bottomleft, topright, bottomright, midtop, midleft, midbottom, midright, center, centerx, centery, size, width, height Except the last three ones, 'size', 'width' and 'height' any of those can be assigned similarily to the pygame.Rect: widget.top = 10 widget.center = (10, 10) ... Note: This will only work for toplevel widgets as widgets are placed relative to their parent. Thus the 'top' attribute value of a widget, which is packed into another one, refers to its parents coordinates. So if it is placed four pixels to the left on its parent, its 'top' value will be 4, while the parent might be placed at e.g. 100, 100. You can get the absolute coordinates, the widget is placed on the display, by using the rect_to_client() method. To get the actual dimensions of the widget, it provides the read-only 'width', 'height' and 'size' attributes. if (widget.width > 50) or (widget.height > 50): ... if widget.size == (50, 50): ... To force a specific minimum size to occupy by the widget, the 'minsize' attribute or the respective set_minimum_size() method can be used. The occupied area of the widget will not be smaller than the size, but can grow bigger. widget.minsize = 100, 50 widget.set_minimum_size (10, 33) The counterpart of 'minsize' is the 'maxsize' attribute, which defines the maximum size, the widget can grow to. It will never exceed that size. widget.maxsize = 200, 200 wdget.set_maximum_size (100, 22) The 'image' and 'rect' attributes are used and needed by the pygame.sprite system. 'image' refers to the visible surface of the widget, which will be blitted on the display. 'rect' is a copy of the pygame.Rect object indicating the occupied area of the widget. The rect denotes the relative position of the widget on its parent (as explained above). The 'index' attribute and set_index() method set the navigation index position for the widget. It is highly recommended to set this value in order to provide a better accessibility (e.g. for keyboard navigation). The attribute can be used in ocempgui.access.IIndexable implementations for example. widget.index = 3 widget.set_index (0) Widgets support a 'style' attribute and create_style() method, which enable them to use different look than default one without the need to override their draw() method. The 'style' attribute of a widget usually defaults to a None value and can be set using the create_style() method. This causes the widget internals to setup the specific style for the widget and can be accessed through the 'style' attribute later on. A detailled documentation of the style can be found in the Style class. if not widget.style: widget.create_style () # Setup the style internals first. widget.style['font']['size'] = 18 widget.create_style ()['font']['name'] = Arial Widgets can be in different states, which cause the widgets to have a certain behaviour and/or look. Dependant on the widget, the actions it supports and actions, which have taken place, the state of the widget can change. The actual state of the widget can be looked up via the 'state' attribute and is one of the STATE_TYPES constants. if widget.state == STATE_INSENSITIVE: print 'The widget is currently insensitive and does not react.' Any widget supports layered drawing through the 'depth' attribute. The higher the depth is, the higher the layer on the z-axis will be, on which the widget will be drawn. Widgets might use the flag to set themselves on top or bottom of the display. # The widget will be placed upon all widgets with a depth lower than 4. widget.depth = 4 widget.set_depth (4) Widgets should set the 'dirty' attribute to True, whenever an update of the widget surface is necessary, which includes redrawing the widget (resp. calling draw_bg() and draw()). In user code, 'dirty' usually does not need to be modified manually, but for own widget implementations it is necessary (e.g. if a Label text changed). If the 'parent' attribute of the widget is set, the parent will be notified automatically, that it has to update portions of its surface. # Force redrawing the widget on the next update cycle of the render # group. widget.dirty = True Widgets support a focus mode, which denotes that the widget has the current input and action focus. Setting the focus can be done via the 'focus' attribute or the set_focus() method. widget.focus = True widget.set_focus (True) 'sensitive' is an attribute, which can block the widget's reaction upon events temporarily. It also influences the look of the widget by using other style values (see STATE_INSENSITIVE in the Style class). widget.sensitive = False widget.set_sensitive (False) Each widget supports transparency, which also includes all children which are drawn on it. By setting the 'opacity' attribute you can adjust the degree of transparency of the widget. The allowed values are ranged between 0 for fully transparent and 255 for fully opaque. widget.opacity = 100 widget.set_opacity (25) Widgets allow parent-child relationships via the 'parent' attribute. Parental relationships are useful for container classes, which can contain widgets and need to be informed, when the widget is destroyed, for example. Take a look the Bin and Container classes for details about possible implementations. Do NOT modify the 'parent' attribute value, if you do not know, what might happen. Widgets support locking themselves self temporarily using the lock() method. This is extremely useful to avoid multiple update/draw calls, when certain operations take place on it. To unlock the widget, the unlock() method should be called, which causes it to update itself instantly. widget.lock () # Acquire lock. widget.focus = False # Normally update() would be called here. widget.sensitive = False # Normally update() would be called here. widget.unlock () # Release lock and call update(). When using the lock() method in your own code, you have to ensure, that you unlock() the widget as soon as you do not need the lock anymore. The state of the lock on a widget can be queried using the 'locked' attribute: if widget.locked: print 'The widget is currently locked' Widgets can consist of other widgets. To guarantee that all of them will be added to the same event management system, set the same state, etc., the 'controls' attribute exists. It is a collection to and from which widgets can be attached or detached. Several methods make use of this attribute by iterating over the attached widgets and invoking their methods to put them into the same state, etc. as the main widget. widget.controls.append (sub_widget) for sub in widget.controls: ... Default action (invoked by activate()): None, will raise an NotImplementedError Mnemonic action (invoked by activate_mnemonic()): None Signals: SIG_FOCUSED - Invoked, when the widget received the focus (widget.focus=True). SIG_ENTER - Invoked, when the input device enters the widget. SIG_LEAVE - Invoked, when the input device leaves the wigdet. SIG_DESTROYED - Invoked, when the widget is destroyed. Attributes: minsize - Guaranteed size of the widget. maxsize - Counterpart to size and denotes the maximum size the widget. is allowed to occupy. Defaults to None usually. image - The visible surface of the widget. index - Navigation index of the widget. style - The style to use for drawing the widget. state - The current state of the widget. depth - The z-axis layer depth of the widget. dirty - Indicates, that the widget needs to be updated. focus - Indicates, that the widget has the current input focus. sensitive - Indicates, if the user can interact with the widget. parent - Slot for the creation of parent-child relationships. controls - Collection of attached controls for complex widgets. tooltip - The tool tip text to display for the widget. opacity - The degree of transparency to apply (0-255, 0 for fully transparent, 255 for fully opaque). indexable - The ocempgui.access.IIndexable implementation to use for the 'index' attribute support. entered - Indicates, that an input device is currently over the widget (e.g. the mouse cursor). locked - Indicates, whether the widget is locked. rect - The area occupied by the widget. x, y, ... - The widget allows to reposition itself through the various width, ... attributes offered by its rect attribute. size """ def __init__ (self): BaseObject.__init__ (self) sprite.Sprite.__init__ (self) # Guaranteed sizes for the widget, see also the minsize/maxsize # attributes and set_*_size () methods. self._minwidth = 0 self._minheight = 0 self._maxwidth = 0 self._maxheight = 0 self._indexable = None self._image = None self._rect = Rect (0, 0, 0, 0) self._oldrect = Rect (0, 0, 0, 0) self._opacity = 255 self._style = None self._index = 0 self._state = STATE_NORMAL self._focus = False self._entered = False self._sensitive = True self._controls = [] self._depth = 0 self._dirty = True self._lock = 0 self._bg = None self.parent = None # Accessibility. self._tooltip = None # Signals, the widget listens to by default self._signals[SIG_FOCUSED] = [] self._signals[SIG_ENTER] = [] self._signals[SIG_LEAVE] = [] self._signals[SIG_DESTROYED] = [] def _get_rect_attr (self, attr): """W._get_rect_attr (...) -> var Gets the wanted attribute value from the underlying rect. """ return getattr (self._rect, attr) def _set_rect_attr (self, attr, value): """W._set_rect_attr (...) -> None Sets a specific attribute value on the underlying rect. Raises an AttributeError if the attr argument is the width, height or size. """ if attr in ("width", "height", "size"): # The width and height are protected! raise AttributeError ("%s attribute is read-only" % attr) # TODO: This is just a hack around wrong positioning in # containers. self._oldrect = self.rect setattr (self._rect, attr, value) if (self.parent != None): if not isinstance (self.parent, BaseWidget): self.update () else: self._oldrect = self.rect def initclass (cls): """B.initclass () -> None Class method to expose the attributes of the own self.rect attribute. The method usually is called in the __init__.py script of the module. """ attributes = dir (Rect) for attr in attributes: if not attr.startswith ("__") and \ not callable (getattr (Rect, attr)): def get_attr (self, attr=attr): return cls._get_rect_attr (self, attr) def set_attr (self, value, attr=attr): return cls._set_rect_attr (self, attr, value) prop = property (get_attr, set_attr) setattr (cls, attr, prop) initclass = classmethod (initclass) def _get_rect (self): """W._get_rect () -> pygame.Rect Gets a copy of the widget's rect. """ return Rect (self._rect) # DEPRECATED def set_position (self, x, y): """W.set_position (...) -> None DEPRECATED - use the 'topleft' attribute instead """ print "*** Warning: set_position() is deprecated, use the topleft" print " attribute instead." self._set_rect_attr ("topleft", (x, y)) def rect_to_client (self, rect=None): """W.rect_to_client (...) -> pygame.Rect Returns the absolute coordinates a rect is located at. In contrast to the widget.rect attribute, which denotes the relative position and size of the widget on its parent, this method returns the absolute position and occupied size on the screen for a passed rect. Usually this method will be called by children of the callee and the callee itself to detrmine their absolute positions on the screen. """ if self.parent and isinstance (self.parent, BaseWidget): re = self.rect if rect != None: re.x += rect.x re.y += rect.y re.width = rect.width re.height = rect.height return self.parent.rect_to_client (re) elif rect != None: rect.x = self.x + rect.x rect.y = self.y + rect.y return rect return self.rect def set_minimum_size (self, width, height): """W.set_minimum_size (...) -> None Sets the minimum size to occupy for the widget. Minimum size means that the widget can exceed the size by any time, but its width and height will never be smaller than these values. Raises a TypeError, if the passed arguments are not integers. Raises a ValueError, if the passed arguments are not positive. """ if (type (width) != int) or (type (height) != int): raise TypeError ("width and height must be positive integers") if (width < 0) or (height < 0): raise ValueError ("width and height must be positive integers") self._minwidth = width self._minheight = height self.dirty = True # DEPRECATED def set_size (self, width, height): """W.set_size (...) -> None DEPREACATED - use set_minimum_size () instead. """ print "*** Warning: set_size() is deprecated, use set_minimum_size()." self.set_minimum_size (width, height) def set_maximum_size (self, width, height): """W.set_maximum_size (...) -> None Sets the maximum size the widget is allowed to occupy. This is the counterpart to the set_minimum_size() method. """ if (type (width) != int) or (type (height) != int): raise TypeError ("width and height must be positive integers") if (width < 0) or (height < 0): raise ValueError ("width and height must be positive integers") self._maxwidth = width self._maxheight = height self.dirty = True def check_sizes (self, width, height): """W.check_sizes (...) -> int, int Checks the passed width and height for allowed values. Checks, whether the passed width an height match the upper and lower size ranges of the widget and returns corrected values, if they exceed those. Else the same values are returned. """ minwidth, minheight = self.minsize maxwidth, maxheight = self.maxsize if (minwidth != 0) and (width < minwidth): width = minwidth elif (maxwidth != 0) and (width > maxwidth): width = maxwidth if (minheight != 0) and (height < minheight): height = minheight elif (maxheight != 0) and (height > maxheight): height = maxheight return width, height def set_index (self, index): """W.set_index (...) -> None Sets the tab index of the widget. Sets the index position of the widget to the given value. It can be used by ocempgui.access.IIndexable implementations to allow easy navigation access and activation for the widgets. Raises a TypeError, if the passed argument is not a positive integer. """ if (type (index) != int) or (index < 0): raise TypeError ("index must be a positive integer") self._index = index def set_depth (self, depth): """W.set_depth (...) -> None Sets the z-axis layer depth for the widget. Sets the z-axis layer depth for the widget. This will need a renderer, which makes use of layers such as the Renderer class. By default, the higher the depth value, the higher the drawing layer of the widget is. That means, that a widget with a depth of 1 is placed upon widgets with a depth of 0. Raises a TypeError, if the passed argument is not an integer. """ if type (depth) != int: raise TypeError ("depth must be an integer") self.lock () old = self._depth self._depth = depth if isinstance (self.parent, BaseWidget): try: self.parent.update_layer (old, self) except: pass for c in self._controls: c.set_depth (depth) self.unlock () def set_dirty (self, dirty, update=True): """W.set_dirty (...) -> None Marks the widget as dirty. Marks the widget as dirty, so that it will be updated and redrawn. """ self._dirty = dirty if dirty and update: self.update () def set_event_manager (self, manager): """W.set_event_manager (...) -> None Sets the event manager of the widget and its controls. Adds the widget to an event manager and causes its controls to be added to the same, too. """ BaseObject.set_event_manager (self, manager) for control in self.controls: control.set_event_manager (manager) def set_indexable (self, indexable): """W.set_indexable (...) -> None Sets the IIndexable for the widget. The widget will invoke the add_index() method for itself on the IIndexable. """ if indexable and not isinstance (indexable, IIndexable): raise TypeError ("indexable must inherit from IIndexable") if self._indexable == indexable: return if self._indexable != None: self._indexable.remove_index (self) self._indexable = indexable if indexable != None: indexable.add_index (self) for ctrl in self.controls: ctrl.set_indexable (indexable) # DEPRECATED def get_style (self): """W.get_style () -> WidgetStyle DEPRECATED - use the create_style() method instead """ print "*** Warning: get_style() is deprecated, use the create_style()" print " method instead." return self.create_style () def create_style (self): """W.create_style () -> WidgetStyle Creates the instance-specific style for the widget. Gets the style associated with the widget. If the widget had no style before, a new one will be created for it, based on the class name of the widget. The style will be copied internally and associated with the widget, so that modifications on it will be instance specific. More information about how a style looks like and how to modify them can be found in the Style class documentation. """ if not self._style: # Create a new style from the base style class. self._style = base.GlobalStyle.copy_style (self.__class__) self._style.set_value_changed (lambda: self.set_dirty (True)) return self._style def set_style (self, style): """W.set_style (...) -> None Sets the style of the widget. Sets the style of the widget to the passed style dictionary. This method currently does not perform any checks, whether the passed dictionary matches the criteria of the Style class. Raises a TypeError, if the passed argument is not a WidgetStyle object. """ if not isinstance (style, WidgetStyle): raise TypeError ("style must be a WidgetStyle") self._style = style if not self._style.get_value_changed (): self._style.set_value_changed (lambda: self.set_dirty (True)) self.dirty = True def set_focus (self, focus=True): """W.set_focus (...) -> bool Sets the input and action focus of the widget. Sets the input and action focus of the widget and returns True upon success or False, if the focus could not be set. """ if not self.sensitive: return False if focus: if not self._focus: self._focus = True self.emit (SIG_FOCUSED, self) self.dirty = True self.run_signal_handlers (SIG_FOCUSED) else: if self._focus: self._focus = False self.dirty = True return True def set_entered (self, entered): """W.set_entered (...) -> None Sets the widget into an entered mode. """ if entered: if not self._entered: self._entered = True self.state = STATE_ENTERED self.emit (SIG_ENTER, self) self.run_signal_handlers (SIG_ENTER) elif self._entered: self._entered = False self.state = STATE_NORMAL self.run_signal_handlers (SIG_LEAVE) def set_sensitive (self, sensitive=True): """W.set_sensitive (...) -> None Sets the sensitivity of the widget. In a sensitive state (the default), widgets can react upon user interaction while they will not do so in an insensitive state. To support the visibility of this, the widget style should support the STATE_INSENSITIVE flag, while inheriting widgets should check for the sensitivity to enable or disable the event mechanisms. """ if sensitive != self._sensitive: if sensitive: self._sensitive = True self.state = STATE_NORMAL else: self._sensitive = False self.state = STATE_INSENSITIVE for control in self.controls: control.set_sensitive (sensitive) def set_state (self, state): """W.set_state (...) -> None Sets the state of the widget. Sets the state of the widget. The state of the widget is mainly used for the visible or non-visible appearance of the widget, so that the user can determine the state of the widget easier. Usually this method should not be invoked by user code. Raises a ValueError, if the passed argument is not a value of the STATE_TYPES tuple. """ if state not in STATE_TYPES: raise ValueError ("state must be a value from STATE_TYPES") if self._state != state: self._state = state self.dirty = True def set_opacity (self, opacity): """W.set_opacity (...) -> None Sets the opacity of the widget. """ if type (opacity) != int: raise TypeError ("opacity must be an integer") dirty = self._opacity != opacity self._opacity = opacity self.update () # DEPRECATED def set_event_area (self, area): """W.set_event_area (...) -> None DEPRECATED - this is no longer used. """ print "*** Warning: set_event_area() is no longer used!" def lock (self): """W.lock () -> None Acquires a lock on the Widget to suspend its updating methods. """ self._lock += 1 def unlock (self): """W.unlock () -> None Releases a previously set lock on the Widget and updates it instantly. """ if self._lock > 0: self._lock -= 1 if self._lock == 0: self.update () def set_tooltip (self, tooltip): """W.set_tooltip (...) -> None Sets the tooltip information for the widget. Raises a TypeError, if the passed argument is not a string or unicode. """ if type (tooltip) not in (str, unicode): raise TypeError ("text must be a string or unicode") self._tooltip = tooltip def activate (self): """W.activate () -> None Activates the widget. Activates the widget, which means, that the default action of the widget will be invoked. This method should be implemented by inherited widgets. """ raise NotImplementedError def activate_mnemonic (self, mnemonic): """W.activate_mnemonic (...) -> bool Activates the widget through the set mnemonic. Activates the widget through the set mnemonic for it and returns True upon successful activation or False, if the widget was not activated. The BaseWidget.activate_mnemonic () method always returns False by default, so that this method should be implemented by inherited widgets, if they need explicit mnemonic support. """ return False def draw_bg (self): """W.draw_bg () -> Surface Draws the widget background surface and returns it. Creates the visible background surface of the widget and returns it to the caller. This method has to be implemented by inherited widgets. """ raise NotImplementedError def draw (self): """W.draw () -> None Draws the widget surface. Creates the visible surface of the widget and updates its internals. """ # Original surface. self._bg = self.draw_bg () try: self._bg = self._bg.convert () except PygameError: pass rect = self._bg.get_rect () # Current surface for blits. self._image = Surface ((rect.width, rect.height)) self._image.blit (self._bg, (0, 0)) topleft = self._rect.topleft self._rect = rect self._rect.topleft = topleft self._oldrect = self.rect def notify (self, event): """W.notify (...) -> None Notifies the widget about an event. Note: Widgets, which are not visible (not shown) or are in a specific state (e.g. STATE_INSENSITIVE), usually do not receive any events. But dependant on the widget, this behaviour can be different, thus checking the visibility depends on the widget and implementation. """ if not self.sensitive: return if (event.signal == SIG_FOCUSED) and (event.data != self): self.focus = False elif (event.signal == SIG_ENTER) and (event.data != self): self.entered = False def update (self, **kwargs): """W.update (...) -> None Updates the widget. Updates the widget and causes its parent to update itself on demand. """ if self.locked: return oldrect = Rect (self._oldrect) resize = kwargs.get ("resize", False) if not self.dirty: children = kwargs.get ("children", {}) blit = self.image.blit items = children.items () # Clean up the dirty areas on the widget. for child, rect in items: blit (self._bg, rect, rect) # Blit the changes. for child, rect in items: blit (child.image, child.rect) self._image.set_alpha (self.opacity) # If a parent's available, reassign the child rects, so that # they point to the absolute position on the widget and build # one matching them all for an update. if self.parent: vals = children.values () rect = oldrect if len (vals) != 0: rect = vals[0] x = self.x y = self.y for r in vals: r.x += x r.y += y rect.unionall (vals[1:]) self.parent.update (children={ self : rect }, resize=resize) self._lock = max (self._lock - 1, 0) return # Acquire lock to prevent recursion on drawing. self._lock += 1 # Draw the widget. self.draw () self._image.set_alpha (self.opacity) if self.parent != None: resize = oldrect != self._rect self.parent.update (children={ self : oldrect }, resize=resize) # Release previously set lock. self._lock = max (self._lock - 1, 0) self.dirty = False def destroy (self): """W.destroy () -> None Destroys the widget and removes it from its event system. Causes the widget to destroy itself as well as its controls and removes all from the connected event manager and sprite groups using the sprite.kill() method. """ if isinstance (self.parent, BaseWidget): raise AttributeError ("widget still has a parent relationship") self.run_signal_handlers (SIG_DESTROYED) self.emit (SIG_DESTROYED, self) # Clear the associated controls. _pop = self._controls.pop while len (self._controls) > 0: control = _pop () control.parent = None control.destroy () del control del self._controls if self._indexable != None: index = self._indexable self._indexable = None index.remove_index (self) if self._manager != None: self._manager.remove_object (self) BaseObject.destroy (self) # Clear BaseObject internals. self.kill () # Clear Sprite #del self.parent del self._indexable del self._bg del self._style del self._image del self._rect del self._oldrect del self # DEPRECATED position = property (lambda self: self.topleft, lambda self, (x, y): self.set_position (x, y), doc = "The position of the topleft corner.") eventarea = property (lambda self: self.rect_to_client (), lambda self, var: self.set_event_area (var), doc = "The area, which gets the events.") minsize = property (lambda self: (self._minwidth, self._minheight), lambda self, (w, h): self.set_minimum_size (w, h), doc = "The guaranteed size of the widget.") maxsize = property (lambda self: (self._maxwidth, self._maxheight), lambda self, (w, h): self.set_maximum_size (w, h), doc = "The maximum size to occupy by the widget.") image = property (lambda self: self._image, doc = "The visible surface of the widget.") rect = property (lambda self: self._get_rect (), doc = "The area occupied by the widget.") index = property (lambda self: self._index, lambda self, var: self.set_index (var), doc = "The tab index position of the widget.") style = property (lambda self: self._style, lambda self, var: self.set_style (var), doc = "The style of the widget.") state = property (lambda self: self._state, lambda self, var: self.set_state (var), doc = "The current state of the widget.") focus = property (lambda self: self._focus, lambda self, var: self.set_focus (var), doc = "The focus of the widget.") sensitive = property (lambda self: self._sensitive, lambda self, var: self.set_sensitive (var), doc = "The sensitivity of the widget.") dirty = property (lambda self: self._dirty, lambda self, var: self.set_dirty (var), doc = """Indicates, whether the widget need to be redrawn.""") controls = property (lambda self: self._controls, doc = "Widgets associated with the widget.") depth = property (lambda self: self._depth, lambda self, var: self.set_depth (var), doc = "The z-axis layer depth of the widget.") tooltip = property (lambda self: self._tooltip, lambda self, var: self.set_tooltip (var), doc = "The tool tip text to display for the widget.") locked = property (lambda self: self._lock > 0, doc = "Indicates, whether the widget is locked.") indexable = property (lambda self: self._indexable, lambda self, var: self.set_indexable (var), doc = "The IIndexable, the widget is attached to.") entered = property (lambda self: self._entered, lambda self, var: self.set_entered (var), doc = "Indicates, whether the widget is entered.") opacity = property (lambda self: self._opacity, lambda self, var: self.set_opacity (var), doc = "The opacity of the widget.")