Class dGridSizer

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 HGap 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
HGap property. If DynamicHGap is set to None (the default), HGap
will not be dynamically evaluated.

Dynamically determine the value of the MaxCols 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
MaxCols property. If DynamicMaxCols is set to None (the default), MaxCols
will not be dynamically evaluated.

Dynamically determine the value of the MaxDimension 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
MaxDimension property. If DynamicMaxDimension is set to None (the default), MaxDimension
will not be dynamically evaluated.

Dynamically determine the value of the MaxRows 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
MaxRows property. If DynamicMaxRows is set to None (the default), MaxRows
will not be dynamically evaluated.

Dynamically determine the value of the Orientation 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
Orientation property. If DynamicOrientation is set to None (the default), Orientation
will not be dynamically evaluated.

Dynamically determine the value of the VGap 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
VGap property. If DynamicVGap is set to None (the default), VGap
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)

Horizontal gap between cells in the sizer  (int)

Height of the sizer  (int)

Highest col position that contains any item. Read-only.  (int)

Highest row position that contains any item. Read-only.  (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

When adding elements to the sizer, controls the max number of columns to add before a new row is started. (int)

When adding elements to the sizer, this property determines  if we use rows or columns as the limiting value. (char: 'r' or 'c'(default) )

When adding elements to the sizer, controls the max number of rows to add before a new column is started. (int)

The name of the object.  (str)

Alias for the MaxDimensions property. (char: 'r' or 'c'(default) )

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)

Vertical gap between cells in the sizer  (int)

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.

Inserts the passed item at the specified position in the grid. If no
position is specified, the item is inserted at the first available open
cell as specified by the Max* properties.

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

Shortcut for appending multiple items at once.

Alias for append()

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.

This method takes an existing GridSizer, and moves
the contents to the current grid. The properties of each
cell's item are preserved, but row/column Expand settings
must be handled separately.

Need to override this method to draw the outline
properly for the grid.

The idea is this: use the MaxDimension to determine how
we look through the grid. When we find an empty cell, return
its coordinates.

Return the fully qualified name of the object.

Returns True if the specified column is growable.

Given an object that is contained in this grid
sizer, returns a (row,col) tuple for that item's location.

Given an object that is contained in this grid
sizer, returns a (row,col) tuple for that item's cell span.

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.

Given an object and a (row, col) offset, returns
the object at the offset position, or None if no such
object exists.

Returns either the managed item or the sizer item at the
given position if one exists. If not, returns None.

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

Returns the object adjacent to the given object. Possible
values for 'dir' are: left, right, up, down.

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.

Returns True if the specified row is growable.

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)
	

This is not supported for this type of sizer

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.

Move the contents of the specified cell to the target
location. By default, layout() is called; this can be changed when
moving a number of cells by specifying delay=True. In this
event, the calling code is responsible for calling layout() when all
the moving is done.

Moves the object to the given row/col if possible.

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.

Deletes any items contained in the specified column, and
then moves all items to the right of it up to fill the space.

Deletes any items contained in the specified row, and
then moves all items below it up to fill the space.

Sets the 'growable' status of one or more columns.

Sets the col span, keeping the row span the same.

Convenience method for setting all columns and rows of the
sizer to not be growable.

Convenience method for setting all columns and rows of the
sizer to be growable. Must be called after all items are added,
as any rows or columns added after the call will be the default
of non-growable.

Given an object that is contained in this grid
sizer, sets its span to the given values. Returns
True if successful, or False if it fails, due to another
item in the way.

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.

Sets the 'growable' status of one or more rows.

Sets the row span, keeping the col span the same.

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.