Class dSizerMixin

Read-only object reference to the Dabo Application object.  (dApp).

The base Dabo class of the object. Read-only.  (class)

Base key used when saving/restoring preferences  (str)

List of all the objects (controls, sizers, spacers) that are directly managed
by this sizer  (list of objects

List of all the sizers that are directly managed by this sizer  (list of sizers

List of all the spacer items that are directly managed by this sizer  (list of spacer items

List of all the windows that are directly managed by this sizer  (list of controls

List of all the sizer items managed by this sizer  (list of sizerItems

The class the object is based on. Read-only.  (class)

Reference to the sizer that controls this control's layout.  (dSizer)

Reference to the sizer item that control's this control's layout.
This is useful for getting information about how the item is being
sized, and for changing those settings.

Sets a default value for the border that will be applied to any controls added
to the sizer afterwards for whom an explicit value for the border is not set.
Note that it does not affect the border of items already added to the control.
This property is useful when you want to add a series of items to a sizer with
the same border: just set this property once, and then add your items.
Default=0  (int)

When True, the DefaultBorder property is applied to all of the sides of
any controls added to the sizer. If any of the individual side properties,
such as DefaultBorderTop, are set to False, this property will return False.
Setting DefaultBorderAll will effectively set all of the individual side properties
to that value. Default=True  (bool)

Affects whether the DefaultBorder property is applied to the Bottom
side of controls added to the sizer. Default=True  (bool)

Affects whether the DefaultBorder property is applied to the Left
side of controls added to the sizer. Default=True  (bool)

Affects whether the DefaultBorder property is applied to the Right
side of controls added to the sizer. Default=True  (bool)

Affects whether the DefaultBorder property is applied to the Top
side of controls added to the sizer. Default=True  (bool)

Amount of space automatically inserted between elements.  (int)

Dynamically determine the value of the DefaultBorder property.

Specify a function and optional arguments that will get called from the
update() method. The return value of the function will get set to the
DefaultBorder property. If DynamicDefaultBorder is set to None (the default), DefaultBorder
will not be dynamically evaluated.

Dynamically determine the value of the Visible property.

Specify a function and optional arguments that will get called from the
update() method. The return value of the function will get set to the
Visible property. If DynamicVisible is set to None (the default), Visible
will not be dynamically evaluated.

Form with which the sizer is associated.  (dForm or None)

Height of the sizer  (int)

Specifies which events to log.  (list of strings)

If the first element is 'All', all events except the following listed events
will be logged.
Event logging is resource-intensive, so in addition to setting this LogEvents
property, you also need to make the following call:

	>>> dabo.eventLogging = True

The name of the object.  (str)

Sets the orientation of the sizer, either 'Vertical' or 'Horizontal'.

The object that contains this sizer. In the case of nested
sizers, it is the object that the outermost sizer belongs to. (obj)

Reference to the Preference Management object  (dPref)

Specifies whether the sizer and contained items are shown  (bool)

Width of this sizer  (int)

Subclass hook. Called after the object's __init__ has run fully.
Subclasses should place their __init__ code here in this hook, instead of
overriding __init__ directly, to avoid conflicting with base Dabo behavior.

Adds the passed object to the end of the sizer layout.

+--------------------------------------------------------------------------+
|Additional arguments:                                                     |
+=============+============================================================+
|layout:      |Specifies how the object expands in the opposite dimension  |
|             |of the sizer. If "normal" (the default), no expansion takes |
|             |place. If "expand" (a common setting), the item will expand |
|             |to fill up otherwise unoccupied space in the sizer.         |
+-------------+------------------------------------------------------------+
|proportion   |Specifies the proportional amount of space that the object  |
|             |can grow to in the same dimension as this sizer. If 0 (the  |
|             |default), the object will maintain its size. If > 0, the    |
|             |object will get a spacing in the sizer proportional to      |
|             |other objects in the sizer with proportions > 0. So if this |
|             |is a horizontal sizer, and the proportion for the object is |
|             |set to 1, and no other objects in the sizer have proportion |
|             |set, the object will fill up all extra horizontal space.    |
+-------------+------------------------------------------------------------+
|alignment    |Possible values are "top", "middle", and "bottom" for       |
|             |horizontal sizers, and "left", "center", and "right" for    |
|             |vertical sizers. Specifies where the object appears within  |
|             |the available area in the sizer.                            |
+-------------+------------------------------------------------------------+
|halign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|valign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|border       |Specifies the number of pixels to put around the object in  |
|             |the sizer, on the sides specified by the borderSides        |
|             |argument, or by the value of the DefaultBorderLeft,         |
|             |DefaultBorderRight, DefaultBorderTop, and                   |
|             |DefaultBorderBottom boolean properties.                     |
+-------------+------------------------------------------------------------+
|borderSides  |Specifies the sides around the object to place the border   |
|             |specified in the border argument or the DefaultBorder       |
|             |property. This should be a tuple that contains at least     |
|             |some of the values ("left", "right", "top", "bottom")       |
+-------------+------------------------------------------------------------+

Shorthand for sizer.append(obj, 1, "expand").

Append each item to the sizer.

+--------------------------------------------------------------------------+
|Additional arguments:                                                     |
+=============+============================================================+
|layout:      |Specifies how the object expands in the opposite dimension  |
|             |of the sizer. If "normal" (the default), no expansion takes |
|             |place. If "expand" (a common setting), the item will expand |
|             |to fill up otherwise unoccupied space in the sizer.         |
+-------------+------------------------------------------------------------+
|proportion   |Specifies the proportional amount of space that the object  |
|             |can grow to in the same dimension as this sizer. If 0 (the  |
|             |default), the object will maintain its size. If > 0, the    |
|             |object will get a spacing in the sizer proportional to      |
|             |other objects in the sizer with proportions > 0. So if this |
|             |is a horizontal sizer, and the proportion for the object is |
|             |set to 1, and no other objects in the sizer have proportion |
|             |set, the object will fill up all extra horizontal space.    |
+-------------+------------------------------------------------------------+
|alignment    |Possible values are "top", "middle", and "bottom" for       |
|             |horizontal sizers, and "left", "center", and "right" for    |
|             |vertical sizers. Specifies where the object appears within  |
|             |the available area in the sizer.                            |
+-------------+------------------------------------------------------------+
|halign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|valign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|border       |Specifies the number of pixels to put around the object in  |
|             |the sizer, on the sides specified by the borderSides        |
|             |argument, or by the value of the DefaultBorderLeft,         |
|             |DefaultBorderRight, DefaultBorderTop, and                   |
|             |DefaultBorderBottom boolean properties.                     |
+-------------+------------------------------------------------------------+
|borderSides  |Specifies the sides around the object to place the border   |
|             |specified in the border argument or the DefaultBorder       |
|             |property. This should be a tuple that contains at least     |
|             |some of the values ("left", "right", "top", "bottom")       |
+-------------+------------------------------------------------------------+

Appends a spacer to the sizer.

Automatically bind any on*() methods to the associated event.

User code only needs to define the callback, and Dabo will automatically
set up the event binding. This will satisfy lots of common cases where
you want an object or its parent to respond to the object's events.

To use this feature, just define a method on<EventName>(), or	if you
want a parent container to respond to the event, make a method in the
parent on<EventName>_<object Name or RegID>().

For example::
	
	class MyButton(dabo.ui.dButton):
		def onHit(self, evt):
			print "Hit!"

	class MyPanel(dabo.ui.dPanel):
		def afterInit(self):
			self.addObject(MyButton, RegID="btn1")

		def onHit_btn1(self, evt):
			print "panel: button hit!"

When the button is pressed, you'll see both 'hit' messages because of
auto event binding.

If you want to bind your events explicitly, you can turn off auto event
binding by calling::

	 dabo.autoBindEvents = False

This feature is inspired by PythonCard.

Subclass hook. Called before the object is fully instantiated.
Usually, user code should override afterInit() instead, but there may be
cases where you need to set an attribute before the init stage is fully
underway.

Bind a dEvent to a callback function.

Bind a sequence of [dEvent, callback] lists.

This method is called to remove all items from the sizer. If the
optional 'destroy' parameter is set to True, any contained items
will be destroyed. Otherwise, they will remain as is, but no longer
under control of the sizer.

There are some cases where being able to see the sizer
is helpful, such as at design time. This method can be called
to see the outline; it needs to be called whenever the containing
window is resized or repainted.

Return the fully qualified name of the object.

Querying sizers for their contents returns sizer items, not
the actual items. So given a sizer item, this method will return
the actual item in the sizer.

Get the current value of the specified property for the sizer item.
Grid sizers must override with their specific props.

Returns a dict containing all the sizer properties as keys along with
their associated values.

Returns the current position of this sizer in its containing sizer, or None
if there isn't a containing sizer.

Returns a dictionary of property name/value pairs.

If a sequence of properties is passed, just those property values
will be returned. Otherwise, all property values will be returned.
The sequence of properties can be a list, tuple, or plain string
positional arguments. For instance, all of the following are
equivilent::

	print self.getProperties("Caption", "FontInfo", "Form")
	print self.getProperties(["Caption", "FontInfo", "Form"])
	t = ("Caption", "FontInfo", "Form")
	print self.getProperties(t)
	print self.getProperties(\*t)

An exception will be raised if any passed property names don't
exist, aren't actual properties, or are not readable (do not have
getter functions).

However, if an exception is raised from the property getter function,
the exception will get caught and used as the property value in the
returned property dictionary. This allows the property list to be
returned even if some properties can't be evaluated correctly by the
object yet.

Hides the passed item

Hook for subclasses. User code should do custom event binding
here, such as::
	
	self.bindEvent(dEvents.GotFocus, self.customGotFocusHandler)
	

Hook for subclasses. User subclasses should set properties
here, such as::
	
	self.Name = "MyTextBox"
	self.BackColor = (192,192,192)
	

Inserts the passed object into the sizer layout at the specified position.

+--------------------------------------------------------------------------+
|Additional arguments:                                                     |
+=============+============================================================+
|layout:      |Specifies how the object expands in the opposite dimension  |
|             |of the sizer. If "normal" (the default), no expansion takes |
|             |place. If "expand" (a common setting), the item will expand |
|             |to fill up otherwise unoccupied space in the sizer.         |
+-------------+------------------------------------------------------------+
|proportion   |Specifies the proportional amount of space that the object  |
|             |can grow to in the same dimension as this sizer. If 0 (the  |
|             |default), the object will maintain its size. If > 0, the    |
|             |object will get a spacing in the sizer proportional to      |
|             |other objects in the sizer with proportions > 0. So if this |
|             |is a horizontal sizer, and the proportion for the object is |
|             |set to 1, and no other objects in the sizer have proportion |
|             |set, the object will fill up all extra horizontal space.    |
+-------------+------------------------------------------------------------+
|alignment    |Possible values are "top", "middle", and "bottom" for       |
|             |horizontal sizers, and "left", "center", and "right" for    |
|             |vertical sizers. Specifies where the object appears within  |
|             |the available area in the sizer.                            |
+-------------+------------------------------------------------------------+
|halign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|valign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|border       |Specifies the number of pixels to put around the object in  |
|             |the sizer, on the sides specified by the borderSides        |
|             |argument, or by the value of the DefaultBorderLeft,         |
|             |DefaultBorderRight, DefaultBorderTop, and                   |
|             |DefaultBorderBottom boolean properties.                     |
+-------------+------------------------------------------------------------+
|borderSides  |Specifies the sides around the object to place the border   |
|             |specified in the border argument or the DefaultBorder       |
|             |property. This should be a tuple that contains at least     |
|             |some of the values ("left", "right", "top", "bottom")       |
+-------------+------------------------------------------------------------+

Added to be consistent with the sizers' add/insert
design. Inserts a spacer at the specified position.

Returns True if this the containership hierarchy for this control
includes obj.

Layout the items in the sizer.

This is handled automatically when the sizer is resized, but you'll have
to call it manually after you are done adding items to the sizer.

Debugging method. This will list all the members of this sizer,
and if recurse is True, drill down into all contained sizers.

Insert the object at the beginning of the sizer layout.

+--------------------------------------------------------------------------+
|Additional arguments:                                                     |
+=============+============================================================+
|layout:      |Specifies how the object expands in the opposite dimension  |
|             |of the sizer. If "normal" (the default), no expansion takes |
|             |place. If "expand" (a common setting), the item will expand |
|             |to fill up otherwise unoccupied space in the sizer.         |
+-------------+------------------------------------------------------------+
|proportion   |Specifies the proportional amount of space that the object  |
|             |can grow to in the same dimension as this sizer. If 0 (the  |
|             |default), the object will maintain its size. If > 0, the    |
|             |object will get a spacing in the sizer proportional to      |
|             |other objects in the sizer with proportions > 0. So if this |
|             |is a horizontal sizer, and the proportion for the object is |
|             |set to 1, and no other objects in the sizer have proportion |
|             |set, the object will fill up all extra horizontal space.    |
+-------------+------------------------------------------------------------+
|alignment    |Possible values are "top", "middle", and "bottom" for       |
|             |horizontal sizers, and "left", "center", and "right" for    |
|             |vertical sizers. Specifies where the object appears within  |
|             |the available area in the sizer.                            |
+-------------+------------------------------------------------------------+
|halign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|valign       |Only used if the alignment property not set.                |
+-------------+------------------------------------------------------------+
|border       |Specifies the number of pixels to put around the object in  |
|             |the sizer, on the sides specified by the borderSides        |
|             |argument, or by the value of the DefaultBorderLeft,         |
|             |DefaultBorderRight, DefaultBorderTop, and                   |
|             |DefaultBorderBottom boolean properties.                     |
+-------------+------------------------------------------------------------+
|borderSides  |Specifies the sides around the object to place the border   |
|             |specified in the border argument or the DefaultBorder       |
|             |property. This should be a tuple that contains at least     |
|             |some of the values ("left", "right", "top", "bottom")       |
+-------------+------------------------------------------------------------+

Added to be consistent with the sizers' add/insert
design. Inserts a spacer in the first position.

Send the event to all registered listeners.

If uiEvent is sent, dEvents.Event will be able to parse it for useful
information to send along to the callback. 

Additional arguments, if any, are sent along to the constructor	of the
event. While this feature exists so that UI-lib event handlers can pass
along information (such as the keystroke information in a key event), user
code may pass along additional arguments as well, which	will exist in the
event.EventData dictionary property.

In most cases, user code should call raiseEvent() with
the event class (dEvents.Hit, for example) as the only parameter.

Normally just destroys the sizer, leaving any objects
controlled by the sizer intact. But if the 'releaseContents'
parameter is passed as True, all objects contained in the
sizer are destroyed first.

This will remove the item from the sizer. It will not cause
the item to be destroyed unless the 'destroy' parameter is True.
If the item is not one of this sizer's items, no error will be
raised - it will simply do nothing.

Given a sizer item, a property and a value, sets things as you
would expect.

This accepts a dict of properties and values, and
applies them to the specified sizer item.

Sets a group of properties on the object all at once.

You have the following options for sending the properties:
	
	1) Property/Value pair dictionary
	2) Keyword arguments
	3) Both

The following examples all do the same thing::

	self.setProperties(FontBold=True, ForeColor="Red")
	self.setProperties({"FontBold": True, "ForeColor": "Red"})
	self.setProperties({"FontBold": True}, ForeColor="Red")

Sets a group of properties on the object all at once. This
is different from the regular setProperties() method because
it only accepts a dict containing prop:value pairs, and it
assumes that the value is always a string. It will convert
the value to the correct type for the property, and then set
the property to that converted value. If the value needs to be evaluated
in a specific namespace, pass that as the 'context' parameter.

Makes sure that the passed item is visible

Remove a previously registered event binding.

Removes all registrations that exist for the given binding for this
object. If event is None, all bindings for the passed function are
removed. If function is None, all bindings for the passed event are
removed. If both event and function are None, all event bindings are
removed.