class %ZEN.Component.activeHGroup
extends activeGroup
%ZEN.Component.activeHGroup
The active horizontal group is a client-side (JavaScript-heavy)
container widget designed for creating binary partitions of an
area of the active display. An activeHGroup is always specified
with exactly two children (any excess are ignored). These
children may have an arbitrary number of children of their own
but at the top level the strict limit is enforced.
On the client-side, the component will be rendered as a split
pane with left and right partitions, potentially separated by an
adjustment handle. If no geometry restrictions are specified,
the component will attempt to size itself to fill all available
space remaining in the browser window (this behavior, can of
course be overridden by CSS).
There are several properties governing the nature and handling
of the partioning. The split may be speficied as an absolute
reserve of pixels for the left or right pane (with excess pixels
going to the other) or as a constant percentage to be reapportioned
in actual pixels whenever the widget's container is resized. The
split can be marked as either fixed or user-adjustable. It is
possible specify child panes that slide open to a predefined wider
width then the mouse rolls over them and auto-close when the mouse
leaves the region. In the case of auto-expanding panes, it is
possible to define sound effects to accompany the animation.
parameter DEFAULTENCLOSINGCLASS = "activeGroup";
To be compatible with the static layout manager the enclosing class
has to be the generic activeGroup rather than the specific activeHGroup
The activeHGroup is the one used for tuning attributes of the absolutely
positioned elements.
parameter INCLUDEFILES = "zenCSLM.js,zenActiveHGroup.js";
CSV list of additional include files (either .js or .css) that
should be included when this component is used on a page.
By default, the file extension (.js or .css) is used to determine whether an
item in the list is a script include or a style include. You can override
this behavior by adding the terms "script:" or "style:" to the beginning of
the file name or names. This prefix is not used as part of the include filename.
property autoExpand
as %ZEN.Datatype.string;
If defined, this property indicates that one of the two panels
is an auto-open/auto-close sidebar panel and that the panel should
expand when the mouse enters its "split"-defined bounds and grow
until it reaches the width given in the autoExpand parameter. The
value is always interpreted in pixels. A positive value designates
the left pane for auto-expansion. A negative value designates the
right.
The default value (null) indicates that the auto-expansion feature
is not used by this instance of the widget.
property handlePattern
as %ZEN.Datatype.string;
This indicates a file name for an image to use for painting the
dragable partition handle. This image should be at least as wide
as the handle thickness and is repeated vertically along the
length of the handle.
The default value is a PNG file of a left-higlighted gray gradient,
bounded by black on either side.
property handleThickness
as %ZEN.Datatype.string;
This indicates the width of the pane partition handle in pixels.
Due to the dynamic functional nature of the element, the width of
this bar cannot be set via CSS and must be specified via this
property.
The default value is "7", resulting a drag handle a little under
one eight of an inch (2 mm) wide on most screens.
property noResize
as %ZEN.Datatype.string;
if true, this indicates that the user is not to be allowed to
resize the panes.
If false, user adjustment of the pane sizes is allowed via dragging
the pane handle with the mouse. If user resizing is enabled, the
mouse pointer will change to an east-west resize cursor when the
mouse is in potential drag position.
The default value is "false"
property soundFX
as %ZEN.Datatype.string;
This indicates a sound file to be played when an auto-expansion
window grows or shrinks. If not defined or null, no sound
accompanies the animation.
The default is "null"
property split
as %ZEN.Datatype.string;
Defines the division between the two panes.
A value with a % sign is interpreted as a proportional division
between the left and right panes and is recalculated to maintain
this ratio whenever the base division is resized by any means.
Manual adjustment of the value continues to be interpreted as a
percentage split.
A positive value not constaining a percent sign is interpreted as
a fixed reserve width for the left child. Any adjustments to the
total width of the base container are reflected in the geometry of
the right pane only.
A negative value (which cannot contain a % sign) is interpreted as
a fixed width for the right pane. Any adjustments to the total
width of the base container are reflected in the geometry of the
left child.
Manual adjustment of a left or right reserved width will change
the size of the reserve and these fixed sizes will be respected
even as the window is resized.
The default split is "50%"
method %DrawHTML()
The HTML generated here is NOT the final DOM structure of this
component. At the client, the information embedded here will be
used to build a more complex DOM subtree under the control of
an active client-side layout manager. The exact structure of this
expansion is not important for most users of this particular
component, however, it _is_ useful to not that the handle dividing
the panes is of the HTML class zenHPaneHandle for the purposes of
CSS style references.
method getController()
[ Language = javascript ]
method onloadHandler()
[ Language = javascript ]
The code generated by the server is NOT the complete structure
for the activeHGroup. Like other client-side layout managers,
only the necessary meta-data is sent to the client. The main
processing logic is stored in a client-side, cache-able
JavaScript file (zenActiveHGroup.js) To complete the connection
between the meta-data description and the code library, the
manager class must be registered with the generic client-side
layout manager. The generic manager maintains a list of classes
that require special handling and the JavaScript code bodies that
perform such handling. A call to ZLM.initLayout() scans the DOM
to find any meta-data classes (such as this one) and "unpacks"
them into DOM structures for local geometry maintenance. This
is all done behind the scenes via the Zen classes onload handler.
method restoreSplit()
[ Language = javascript ]
method setProperty(property, value, value2)
[ Language = javascript ]
Set the value of a named property.
method showLeftOnly()
[ Language = javascript ]
method showRightOnly()
[ Language = javascript ]