Optional $ZKBINDER$Optional $ZKMATCHMEDIA$Optional $buttonOptional $inputThe object ID. Each object has its own unique $oid. It is mainly used for debugging purpose.
Trick: you can test if a JavaScript object is a ZK object by examining this property, such as `if (o.$oid) alert('o is a ZK object');`
Notice: zk.Class extends from zk.Object (so a class also has $oid)
Optional $weaveThe weave controller that is used by ZK Weaver. It is not null if it is created and controlled by ZK Weaver. In other words, it is called in the Design Mode if Widget.$weave is not null.
Optional autagThe AU tag of this widget.
The AU tag tag is used to tag the AU requests sent by the peer widget.
For instance, if the AU tag is xxx,yyy and the desktop's
request path (Desktop#requestPath) is /foo.zul, then
the URL of the AU request will contain /_/foo.zul/xxx,yyy,.
null
6.0.0
Readonly bindThe bind level (integer).
The level in the widget tree after this widget is bound to a DOM tree (bind_). For example, a widget's bind level is one plus the parent widget's
It starts at 0 if it is the root of the widget tree (a desktop, zk.Desktop), then 1 if a child of the root widget, and son on. Notice that it is -1 if not bound.
It is mainly useful if you want to maintain a list that parent widgets is in front of (or after) child widgets. bind level.
Optional blankThe class name of the widget. For example, zk.Widget's class name is "zk.Widget", while zul.wnd.Window's "zul.wnd.Window".
Notice that it is available if a widget class is loaded by WPD loader (i.e., specified in zk.wpd). If you create a widget class dynamically, you have to invoke register to make this member available. On the other hand, zk.Object.$class is available for all objects extending from zk.Object.
widgetName
Optional Readonly desktopThe desktop that this widget belongs to.
It is set when it is bound to the DOM tree.
Notice it is always non-null if bound to the DOM tree, while Widget.$n is always non-null if bound. For example, zul.utl.Timer.
It is readonly, and set automatically when bind_ is called.
Optional domThe first child, or null if no child at all.
getChildAt
Optional Readonly idReadonly inWhether this widget has a peer component.
It is set if a widget is created automatically to represent a component
at the server. On the other hand, it is false if a widget is created
by the client application (by calling, say, new zul.inp.Textox()).
The last child, or null if no child at all.
getChildAt
Readonly nThe number of children (integer).
Optional Readonly nextThe next sibling, or null if this widget is the last child.
Optional offsetOptional offsetOptional Readonly parentThe parent, or null if this widget has no parent.
Optional Readonly previousThe previous sibling, or null if this widget is the first child.
Optional prologThe UUID. Don't change it if it is bound to the DOM tree, or inServer is true. Developers rarely need to modify it since it is generated automatically.
The widget name of the widget.
It is the same as this.className.substring(this.className.lastIndexOf('.') + 1).toLowerCase().
For example, if className is zul.wnd.Window, then
widgetName is window.
Notice that className is unique while widgetName is not necessary unique.
className
5.0.2
Optional z$displayOptional z$rodOptional z$rod0Optional z_Optional z_Static $oidStatic $redrawStatic auThe default delay before sending an AU request when fire is called (and the server has an ARAP event listener registered).
38 (Unit: miliseconds).
5.0.8
Static moldsStatic onThe delay for sending the onChanging event (unit: milliseconds). The onChanging event will be sent after the specified delay once the user pressed a keystroke (and changed the value).
350
5.0.1
Static onWhether to send at least one the onChanging event if it is listened and the content is ever changed.
true
5.0.1
the map of all fellows of this widget.
wgt.$f().main.setTitle("foo");
5.0.2
the widget's ID (id)
Optional global: booleanwhether to search all ID spaces of this desktop. If true, it first search its own ID space, and then the other Id spaces in this browser window (might have one or multiple desktops). If omitted, it won't search all ID spaces.
the fellow (Widget) of the specified ID of the ID space that this widget belongs to. It returns undefined if not found.
Determines if this object is an instance of the class represented by the specified Class parameter. Example:
if (obj.$instanceof(zul.wgt.Label, zul.wgt.Image)) {
}
Rest ...klass: any[]the Class object to be checked. Any number of arguments can be specified.
true if this object is an instance of the class
the DOM element that this widget is bound to. It is null if it is not bound to the DOM tree, or it doesn't have the associated DOM node (for example, zul.utl.Timer).
Notice that desktop is always non-null if it is bound to the DOM tree. In additions, this method is much faster than invoking jq() (see _global_.jq, since it caches the result (and clean up at the unbind_). ```ts var n = wgt.$n(); ```
#$n(String)
Optional subId: stringthe sub ID of the child element
the child element of the DOM element(s) that this widget is bound to. This method assumes the ID of the child element the concatenation of uuid, -, and subId. For example,
var cave = wgt.$n('cave'); //the same as jq('#' + wgt.uuid + '-' + 'cave')[0]
Like Widget.$n, this method caches the result so the performance is much better than invoking jq() directly.
Optional subclass: stringthe sub zclass name that cache for this widget. It returns the zclass if the subclass is empty or null, since it caches the result (and clean up at the setZclass).
var subzcls = wgt.$s('hover'); // z-xxx-hover will be return
Invokes a method defined in the superclass with any number of arguments. It is like Function's call() that takes any number of arguments.
Example: ```ts multiply: function (n) { return this.$super('multiply', n + 2); } ```
the object being returned by the method of the superclass.
Invokes a method defined in the superclass with any number of arguments. It is like Function's call() that takes any number of arguments.
It is similar to ZKObject.$super, but this method works even if the superclass calls back the same member method. In short, it is tedious but safer.
Example: ```ts foo.MyClass = zk.$extends(foo.MySuper, { multiply: function (n) { return this.$super(foo.MyClass, 'multiply', n + 2); } ```
Notice that the class specified in the first argument is not the super class having the method. Rather, it is the class that invokes this method.
the object being returned by the method of the superclass.
Invokes a method defined in the superclass with an array of arguments. It is like Function's apply() that takes an array of arguments.
Example: ```ts multiply: function () { return this.$supers('multiply', arguments); } ```
the object being returned by the method of the superclass.
Invokes a method defined in the superclass with an array of arguments. It is like Function's apply() that takes an array of arguments.
It is similar to zk.Object.$supers, but this method works even if the superclass calls back the same member method. In short, it is tedious but safer.
Example: ```ts foo.MyClass = zk.$extends(foo.MySuper, { multiply: function () { return this.$supers(foo.MyClass, 'multiply', arguments); } ```
Notice that the class specified in the first argument is not the super class having the method. Rather, it is the class that invokes this method.
the object being returned by the method of the superclass.
Optional kid: Widget<HTMLElement>Specifies a function that shall be called after the object is initialized, i.e., after zk.Object.$init is called. This method can be called only during the execution of zk.Object.$init.
It is an advance feature that is used to allow a base class to do something that needs to wait for all deriving classes have been initialized.
Invocation Sequence:
the function to register for execution later
Append a child widget. The child widget will be attached to the DOM tree automatically, if this widget has been attached to the DOM tree, unless this widget is zk.Desktop. In other words, you have to attach child widgets of zk.Desktop manually (by use of, say, replaceHTML).
whether the widget was added successfully. It returns false if the child is always the last child (lastChild).
A callback called before removing a child.
the child being removed.
10.0.0
Callback before sending an AU request. It is called by sendAU_.
this method will stop the event propagation
and prevent the browser's default handling
(by calling {@link zk.Event#stop}),
if the event is onClick, onRightClick or onDoubleClick.
<p>Notice that {@link sendAU_} is called against the widget sending the AU request
to the server, while {@link beforeSendAU_} is called against the event's
target (evt.target).
<p>Notice that since this method will stop the event propagation for onClick,
onRightClick and onDoubleClick, it means the event propagation is stopped
if the server registers a listener. However, it doesn't stop if
only a client listener is registered (and, in this case, {@link zk.Event#stop}
must be called explicitly if you want to stop).
5.0.2
Binds this widget. It is called to associate (aka., attach) the widget with the DOM tree.
Notice that you rarely need to invoke this method, since it is called automatically (such as replaceHTML and appendChild).
Notice that you rarely need to override this method, either. Rather, override bind_ instead.
Binds the children of this widget. It is called by bind_ to invoke child's bind_ one-by-one.
Optional desktop: Desktopthe desktop the DOM element belongs to. If not specified, ZK will decide it automatically.
Optional skipper: Skipperused if rerender is called with a non-null skipper.
Optional after: CallableFunction[]an array of function (Function) that will be invoked after bind_ has been called. For example,
5.0.5
Checks if this widget can be activated (gaining focus and so on).
Optional opts: Partial<{ the options. Allowed values:
return false if it is not a descendant of
{@link _global_.zk#currentModal}.
Cleans up the widget to make it un-draggable. It is called if getDraggable is cleaned (or unbound).
You rarely need to override this method, unless you want to handle drag-and-drop differently.
Clears the cached nodes (by Widget.$n).
Clears the error message and the error status.
It is also called by zk.AuCmd0#clearWrongValue (from the server).
whether to re-validate the value next time onblur occurs
Optional remainError: booleanwhether the input widget remains in the error status, if any, after the invocation.
Called to create the visual effect representing what is being dragged. In other words, it creates the DOM element that will be moved with the mouse pointer when the user is dragging.
This method is called if getDragMessage_ returns null. If getDragMessage_ returns a string (empty or not), a small popup containing the message is created to represent the widget being dragged.
You rarely need to override this method, unless you want a different visual effect.
the draggable controller
the offset of the returned element (left/top)
Closes the list of combo items (Comboitem if it was dropped down. It is the same as setOpen(false).
Optional opts: Record<string, unknown>the options.
Renders a fake DOM element that will replace with the correct element after the deferring time is up. The method is designed for some widgets to override, such as Treeitem, Listitem, and Row, whose HTML tag is created inside a table.
By default, the Div tag is assumed.
an array to output the HTML fragments.
5.0.6
Utilities for handling the so-called render defer (setRenderdefer). This method is called automatically by redraw, so you only need to use it if you override redraw.
A typical usage is as follows. ```ts redraw: function (out) { if (!this.deferRedraw_(out)) { out.push(...); //redraw } } ```
an array to output the HTML fragments.
5.0.2
Called when the user double-clicks on a widget or a child widget. A widget doesn't need to listen the dblclick DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and call parent's
doDoubleClick_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
<p>Note: if {@link shallIgnoreClick_} returns true, {@link fireX} won't be
called and this method invokes the parent's {@link doDoubleClick_} instead
(unless {@link zk.Event#stopped} is set).
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user presses a key when this widget has the focus (focus).
Notice that not every widget can have the focus. A widget doesn't need to listen the keypress DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doKeyPress_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user presses down the mouse button on this widget (or one of its child widget). A widget doesn't need to listen the mousedown DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doMouseDown_ if the event propagation is not stopped ({@link zk.Event#stopped}).
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user moves the mouse pointer over this widget (or one of its child widget). A widget doesn't need to listen the mousemove DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doMouseMove_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user moves the mouse pointer out of a widget (or one of its child widget). A widget doesn't need to listen the mouseout DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doMouseOut_ if the event propagation is not stopped ({@link zk.Event#stopped}).
Called when the user moves the mouse pointer on top of a widget (or one of its child widget). A widget doesn't need to listen the mouseover DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doMouseOver_ if the event propagation is not stopped ({@link zk.Event#stopped}).
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user presses up the mouse button on this widget (or one of its child widget). A widget doesn't need to listen the mouseup DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doMouseUp_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user paste text to this widget which has been the focused (focus).
Notice that not every widget can have the focus. A widget doesn't need to listen the paste DOM event. Rather, it shall override this method if necessary.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
fire the widget event ({@link fireX}), and
call parent's doPaste_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Notifications">ZK Client-side Reference: Notifications</a>
Called when the user clicks or right-clicks on widget or a child widget. It is called before doClick_ and doRightClick_.
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
does nothing but invokes the parent's {@link doSelect_}.
Notice that it does not fire any event.
<p>Deriving class that supports selection (such as {@link zul.sel.ItemWidget})
shall override this to handle the selection.
<p>Technically, the selection can be handled in {@link doClick_}.
However, it is better to handle here since this method is invoked first
such that the widget will be selected before one of its descendant widget
handles {@link doClick_}.
<p>Notice that calling {@link zk.Event#stop} will stop the invocation of
parent's {@link doSelect_} and {@link doClick_}/{@link doRightClick_}.
If you just don't want to call parent's {@link doSelect_}, simply
not to invoke super's doSelect_.
5.0.1
Called when the user swipe left/right/up/down this widget.
For example, ```ts var opts = evt.opts, dir = opts.dir; switch (dir) { case 'left': doSwipeLeft(); break; case 'right': doSwipeRight(); break; case 'up': doSwipeUp(); break; case 'down': doSwipeDown(); break; } ``` To define swipe direction rather than default condition, ```ts var opts = evt.opts, start = opts.start, stop = opts.stop, dispT = stop.time - start.time, deltaX = start.coords[0] - stop.coords[0], deltaY = start.coords[1] - stop.coords[1], dispX = Math.abs(deltaX), dispY = Math.abs(deltaY);
//if swipe time is less than 500ms, it is considered as swipe event if (dispT < 500) { //if horizontal displacement is larger than 30px and vertical displacement is smaller than 75px, it is considered swipe left/right if (dispX > 30 && dispY < 75) //swipe left if deltaX > 0
//if vertical displacement is large than 30px and horizontal displacement is smaller than 75px, it is considered swipe up/down else if (dispY > 30 && dispX < 75) //swipe up if deltaY > 0 } ```
the widget event.
fire the widget event ({@link fireX}), and
call parent's doSwipe_ if the event propagation is not stopped ({@link zk.Event#stopped}).
It is the so-called event propagation.
6.5.0
Registers an DOM event listener for the specified DOM element (aka., node). You can use jQuery to listen the DOM event directly, or use this method instead.
bind_: function () {
this.$supers('bind_', arguments);
this.domListen_(this.$n(), "onChange"); //fn is omitted, so _doChange is assumed
this.domListen_(this.$n("foo"), "onSelect", "_doFooSelect"); //specify a particular listener
},
unbind_: function () {
this.domUnlisten_(this.$n(), "onChange"); //unlisten
this.domUnlisten_(this.$n("foo"), "onSelect", "_doFooSelect");
this.$supers('unbind_', arguments);
},
_doChange_: function (evt) { //evt is an instance of zk.Event
//event listener
},
_doFooSelect: function (evt) {
}
See also ZK Client-side Reference: Notifications
a node of this widget. It is usually retrieved by Widget.$n.
the event name to register, such as onClick.
Optional fn: string | CallableFunctionthe name (String) of the member method to handle the event,
or the function (Function).
It is optional. If omitted, _doEvtnm is assumed, where evtnm
is the value passed thru the evtnm argument.
For example, if the event name is onFocus, then the method is assumed to be
_doFocus.
Optional keyword: unknownthe extra argumenet for the function, which is passed into the callback function. (since 7.0)
Optional no: DomStyleOptions[options] the style to exclude (i.e., to turn off).
If omitted, it means none (i.e., all included). For example, you don't
want width to generate, call domStyle_({width:1}).
Notice, though a bit counter-intuition, specify 1 (or true) to denote exclusion.
Allowed value (subclass might support more options):
the style used for the DOM element of this widget, such as "width:100px;z-index:1;"
a concatenation of style, width, visible and so on.
the style attribute that contains only the text related CSS styles. For example, it returns style="font-size:12pt;font-weight:bold" if #getStyle is border:none;font-size:12pt;font-weight:bold.
It is usually used with getTextNode to ZK Client-side Reference: Text Styles and Inner Tags.
the tooltiptext for generating the title attribute of the DOM element.
return {@link getTooltiptext}.
<p>Deriving class might override this method if the parent widget
is not associated with any DOM element, such as treerow's parent: treeitem.
5.0.2
Un-registers an event listener for the specified DOM element (aka., node).
Refer to domListen_ for more information.
the event name to register, such as onClick.
Optional fn: string | CallableFunctionthe name (String) of the member method to handle the event,
or the function (Function).
It is optional. If omitted, _doEvtnm is assumed, where evtnm
is the value passed thru the evtnm argument.
For example, if the event name is onFocus, then the method is assumed to be
_doFocus.
Optional keyword: unknownthe extra argumenet for the function, which is passed into the callback function. (since 7.0)
Called to have some visual effect when the user is dragging a widget over this widget and this widget is droppable. Notice it is the effect to indicate a widget is droppable.
Optional over: booleanwhether the user is dragging over (or out, if false)
it adds the CSS class named 'z-drag-over' if over is true, and remove it if over is false.
Called when the user presses enter when this widget has the focus (focus).
call the close function
the widget event. The original DOM event and target can be retrieved by zk.Event#domEvent and zk.Event#domTarget
Associates UUID with this widget.
Notice that uuid is automatically associated (aka., bound) to this widget. Thus, you rarely need to invoke this method unless you want to associate with other identifiers.
For example, ZK Google Maps uses this method since it has to bind the anchors manually.
the UUID to assign to the widgtet
whether to bind. Specify true if you want to bind; false if you want to unbind.
Fire a widget event. An instance of zk.Event is created to represent the event.
The event listeners for this event will be called one-by-one unless zk.Event#stop is called.
If the event propagation is not stopped (i.e., zk.Event#stop not called) and inServer is true, the event will be converted to an AU request and sent to the server. Refer to ZK Client-side Reference: AU Requests: Client-side Firing for more information.
the event name, such as onClick
Optional data: unknownthe data depending on the event (zk.Event).
Optional opts: EventOptionsthe options. Refer to zk.Event#opts
Optional timeout: numberthe delay before sending the non-deferrable AU request (if necessary). If not specified or negative, it is decided automatically. It is ignored if no non-deferrable listener is registered at the server.
the event being fired.
Fires the onChange event. If the widget is created at the server, the event will be sent to the server too.
Optional opts: EventOptionsthe options. Refer to zk.Event#opts
5.0.5
Fire a widget event.
the event to fire
Optional timeout: numberthe delay before sending the non-deferrable AU request (if necessary). If not specified or negative, it is decided automatically. It is ignored if no non-deferrable listener is registered at the server.
the event being fired, i.e., evt.
Sets the focus to this widget. This method will check if this widget can be activated by invoking canActivate first.
Notice: don't override this method. Rather, override focus_, which this method depends on.
Optional timeout: numberhow many milliseconds before changing the focus. If not specified or negative, the focus is changed immediately,
whether the focus is gained to this widget.
Forces the rendering if it is deferred. A typical way to defer the render is to specify setRenderdefer with a non-negative value. The other example is some widget might be optimized for the performance by not rendering some or the whole part of the widget. If the rendering is deferred, the corresponding DOM elements (Widget.$n) are not available. If it is important to you, you can force it to be rendered.
Notice that this method only forces this widget to render. It doesn't force any of its children. If you want, you have invoke forcerender one-by-one
The derived class shall override this method, if it implements the render deferring (other than setRenderdefer).
5.0.2
Converts a coordinate related to the browser window into the coordinate related to this widget.
the X coordinate related to the browser window
the Y coordinate related to the browser window
the coordinate related to this widget (i.e., [0, 0] is the left-top corner of the widget).
5.0.2
Called by insertChildHTML_ to find the location to place the DOM element of the child. More precisely, the node returned by getCaveNode is the parent DOM element of the child's DOM element.
this.$n('cave') || this.$n()
You can override it to return whatever DOM element you want.
the index of the child widget to return. 0 means the first child, 1 for the second and so on.
Optional skipHidden: booleanwhether to skip hidden child widgets, defaults to false.
the child widget at the specified index or null if no such index.
Notice this method is not good if there are a lot of children since it iterates all children one by one.
the child index of this widget. By child index we mean the order of the child list of the parent. For example, if this widget is the parent's first child, then 0 is returned.
Notice that getChildAt is called against the parent, while this method called against the child. In other words, `w.parent.getChildAt(w.getChildIndex())` returns `w`.
Notice this method is not good if there are a lot of children since it iterates all children one by one.
the constraint, or null if no constraint at all.
the ID of the popup (zul.wgt.Popup) that should appear when the user right-clicks on the element (aka., context menu).
null (no context menu).
Optional fn: string | CallableFunctionOptional keyword: unknownthe message to show when an user is dragging this widget, or null if it prefers to clone the widget with cloneDrag_.
it return the inner text if if {@link Widget.$n} returns a TR, TD, or TH element. Otherwise, it returns null and {@link cloneDrag_} will be called to create a DOM element to indicate dragging.
<p>Notice that the text would be encoded for XSS issue since 8.0.4.2. It should be considered when overriding.
the default implementation
the options used to instantiate zk.Draggable.
it does nothing but returns the map parameter,
i.e., the default options.
Though rarely used, you can override any option passed to zk.Draggable, such as the start effect, ghosting and so on.
the widget being dragged (never null).
the widget if it allows to drop the specified widget (being dragged), or null if not allowed. It is called when the user is dragging a widget on top a widget.
it check if the values of droppable and draggable match. It will check the parent ({@link parent}), parent's parent, and so on until matched, or none of them are matched.
<p>Notice that the widget to test if droppable might be the same as the widget being dragged (i.e., this == dragged). By default, we consider them as non-matched.
the error message that is caused when user entered invalid value, or null if no error at all.
The error message is set when user has entered a wrong value, or setValue is called with a wrong value. It is cleared once a correct value is assigned.
If the error message is set, we say this input is in the error mode.
the error message that is caused when user entered invalid value, or null if no error at all.
The error message is set when user has entered a wrong value, or setValue is called with a wrong value. It is cleared once a correct value is assigned.
If the error message is set, we say this input is in the error mode.
use getErrorMessage() instead.
the first DOM element of this widget. If this widget has no corresponding DOM element, this method will look for its siblings.
This method is designed to be used with insertChildHTML_ for retrieving the DOM element of the `before` widget.
the element whose z-index needs to be set.
It is the value specified in opts.node when setFloating_
is called. If not specified, it is the same as Widget.$n.
the z-index of a floating widget. It is called by setTopmost to decide the topmost z-index, and called only if setFloating_ is ever called.
the identifier of this widget, or null if not assigned. It is the same as id.
the name of this component.
null.
Don't use this method if your application is purely based on ZK's event-driven model.
The name is used only to work with "legacy" Web application that handles user's request by servlets. It works only with HTTP/HTML-based browsers. It doesn't work with other kind of clients.
the DOM element to match the widget.
the widget associated with the given node element. It is used by replaceHTML and replaceChildHTML_ to retrieve the widget associated with the note.
It is similar to Widget.$ but it gives the widget a chance to handle extreme cases. For example, Treeitem doesn't associate a DOM element (or you can say Treeitem and Treerow shares the same DOM element), so `zk.Widget.$(n)` will return Treerow, not Treeitem. If it is the case, you can override it to make replaceHTML works correctly.
5.0.3
the ID of the popup (zul.wgt.Popup) that should appear when the user clicks on the element.
null (no popup).
the DOM element that is used to hold the text, or null if this widget doesn't show any text.
return null (no text node).
<p>For example, {@link updateDomStyle_} will change the style
of the text node, if any, to make sure the text is displayed correctly.
<p>See also <a href="http://books.zkoss.org/wiki/ZK_Client-side_Reference/Component_Development/Client-side/Text_Styles_and_Inner_Tags">ZK Client-side Reference: Text Styles and Inner Tags</a>.
the ID of the popup (zul.wgt.Popup) that should be used as a tooltip window when the mouse hovers over the element for a moment. The tooltip will automatically disappear when the mouse is moved away.
null (no tooltip).
A widget call this function of its ancestor if it wants to know whether its ancestor prefer ignore float up event of it self.
false.
6.0.0
Initializes the widget to make it draggable. It is called if getDraggable is set (and bound).
You rarely need to override this method, unless you want to handle drag-and-drop differently.
use {@link zk.Draggable} to implement drag-and-drop,
and the handle to drag is the element returned by {@link getDragNode}
Inserts a child widget before the reference widget (the sibling argument).
the child widget
Optional sibling: Widget<HTMLElement>the sibling widget (the 'insert' point where the new widget will be placed before). If null or omitted, it is the same as appendChild
Optional ignoreDom: booleanwhether the widget was added successfully. It returns false if the child is always the last child (lastChild).
Inserts the HTML content generated by the specified child widget before the reference widget (the before argument). It is called by insertBefore and appendChild to handle the DOM tree.
Deriving classes might override this method to modify the HTML content, such as enclosing with TD.
Notice that when inserting the child (without the before argument), this method will call getCaveNode to find the location to place the DOM element of the child. More precisely, the node returned by getCaveNode is the parent DOM element of the child. The default implementation of getCaveNode is to look for a sub-node named uuid$cave. In other words, it tried to place the child inside the so-called cave sub-node, if any. Otherwise, Widget.$n is assumed.
the child widget to insert
Optional before: Widget<HTMLElement>the child widget as the reference to insert the new child before. If null, the HTML content will be appended as the last child. The implementation can use before.getFirstNode_() (getFirstNode_) to retrieve the DOM element
Optional desktop: Desktopwhether to automatically complete this text box by matching the nearest item (Comboitem. It is also known as auto-type-ahead.
true
If true, the nearest item will be searched and the text box is updated automatically. If false, user has to click the item or use the DOWN or UP keys to select it back.
Don't confuse it with the auto-completion feature mentioned by other framework. Such kind of auto-completion is supported well by listening to the onChanging event.
whether this widget is being bound to DOM. In other words, it returns true if bind is called against this widget or any of its ancestors.
5.0.8
Optional opts: Partial<{ the options. If omitted, it checks only if the server registers any non-deferrable listener, and if the client register any listener. Allowed values:
if a listener is registered for the specified event.
Optional opts: RealVisibleOptionsthe options. Allowed values:
if this widget is really visible, i.e., all ancestor widget and itself are visible.
the name of the watch, such as onShow
Optional p: Widget<HTMLElement>the parent widget causing the watch event. It is null if it is not caused by global.zWatch#fireDown.
Optional cache: Record<string, unknown>a map of cached result (since 5.0.8). Ignored if null. If specified, the result will be stored and used to speed up the processing
if the given watch shall be fired for this widget. It is called by zWatch to check if the given watch shall be fired
5.0.3
Registers listener(s) to the specified event. For example,
wgt.listen({
onClick: wgt,
onOpen: wgt._onOpen,
onMove: [o, o._onMove]
});
As shown above, you can register multiple listeners at the same time, and echo value in infos can be a target, a function, or a two-element array, where the first element is a target and the second the function. A target can be any object that this will reference to when the event listener is called. Notice it is not zk.Event#target. Rather, it is `this` when the listener is called.
If the function is not specified, the target must have a method having the same name as the event. For example, if `wgt.listen({onChange: target})` was called, then target.onChange(evt) will be called when onChange event is fired (by fire). On the other hand, if the target is not specified, the widget is assumed to be the target.
Optional priority: numberthe higher the number, the earlier it is called. If omitted, 0 is assumed. If a widget needs to register a listener as the default behavior (such as zul.wnd.Window's onClose), -1000 is suggested
A callback called after a child has been added to this widget.
Notice: when overriding this method, onChildReplaced_ is usually required to override, too.
the child being added
A callback called after a child has been removed to this widget.
Notice: when overriding this method, onChildReplaced_
the child being removed
A callback called after a child has been delay rendered.
the child being rendered
A callback called after a child has been replaced. Unlike onChildAdded_ and onChildRemoved_, this method is called only if zk.AuCmd1#outer. And if this method is called, neither onChildAdded_ nor onChildRemoved_ will be called.
invoke {@link onChildRemoved_} and then
{@link onChildAdded_}.
Furthermore, it sets this.childReplacing_ to true before invoking
{@link onChildRemoved_} and {@link onChildAdded_}, so we can optimize
the code (such as rerender only once) by checking its value.
A callback called after a child's visibility is changed (i.e., setVisible was called).
Notice that this method is called after the _visible property and the associated DOM element(s) have been changed.
To know if it is becoming visible, you can check isVisible (such as this._visible).
the child whose visiblity is changed
Called to fire the onDrop event. You could override it to implement some effects to indicate dropping.
it fires the onDrop event (with {@link fire}).
The subclass can override this method to pass more options such as the coordination where a widget is dropped.
Optional wgt: Widget<HTMLElement>Drops down the list of combo items (Comboitem. It is the same as setOpen(true).
Optional opts: OpenOptionsthe options.
Proxies a member function such that it can be called with this object in a context that this object is not available. It sounds a bit strange at beginning but useful when passing a member of an object that will be executed as a global function.
Example: Let us say if you want a member function to be called periodically, you can do as follows. ```ts setInterval(wgt.proxy(wgt.doIt), 1000); //assume doIt is a member function of wgt ```
With proxy, when doIt is called, this references to wgt. On the other hand, the following won't work since this doesn't reference to wgt, when doIt is called. ```ts setInterval(wgt.doIt, 1000); //WRONG! doIt will not be called with wgt ```
Notice that this method caches the result so that it will return the same proxied function, if you pass the same function again.
a function that can be called as a global function
(that actually have this referencing to this object).
Generates the HTML fragment for this widget. The HTML fragment shall be pushed to out. For example,
out.push('<div', this.domAttrs_(), '>');
for (var w = this.firstChild; w; w = w.nextSibling)
w.redraw(out);
out.push('</div>');
an array to output HTML fragments.
Technically it can be anything that has the method called push
Optional skipper: Skipperit retrieves the redraw function associated with
the mold ({@link getMold}) and then invoke it.
The redraw function must have the same signature as this method.
Optional skipper: Skipperthe skipper. Ignored if null
Optional trim: booleanwhether to trim the HTML content before replacing
the HTML fragment of this widget.
Removes a child with more control. It is similar to removeChild except the caller could prevent it from removing the DOM element.
Notice that the associated DOM elements and unbind_ is called first (i.e., called before beforeParentChanged_, modifying the widget tree, ID space, and onChildRemoved_).
the child to remove.
Optional ignoreDom: booleanwhether to remove the DOM element
whether it is removed successfully.
Removes the corresponding DOM content of the specified child. It is called by removeChild to remove the DOM content.
The default implementation of this method will invoke removeHTML_ if the ignoreDom argument is false or not specified.
Overrides this method or removeHTML_ if you have to remove DOM elements other than child's node (and the descendants).
the child widget to remove
Optional ignoreDom: booleanwhether to remove the DOM element
Removes the HTML DOM content.
The default implementation simply removes the DOM element passed in.
Overrides this method if you have to remove the related DOM elements.
an array of DOMElement to remove. If this widget is associated with a DOM element (Widget.$n returns non-null), n is a single element array. If this widget is not associated with any DOM element, an array of child widget's DOM elements are returned.
5.0.1
Replaced the child widgets with the specified widgets.
It is useful if you want to replace a part of children whose
DOM element is a child element of subId (this.$n(subId)).
Note: it assumes this.$n(subId) exists.
the ID of the cave that contains the child widgets to replace with.
an array of widgets that will become children of this widget
Optional tagBeg: stringthe beginning of HTML tag, such as <tbody>.
Ignored if null.
Optional tagEnd: stringthe ending of HTML tag, such as </tbody>;
Ignored if null.
zAu#createWidgets
Replaces the DOM element(s) of the specified child widget. It is called by replaceHTML to give the parent a chance to do something special for particular child widgets.
Replaces the specified DOM element with the HTML content generated this widget.
It is the same as jq(n).replaceWith(wgt, desktop, skipper).
The DOM element to be replaced can be Widget.$n or any independent DOM element. For example, you can replace a DIV element (and all its descendants) with this widget (and its descendants).
This method is usually used to replace a DOM element with a root widget (though, with care, it is OK for non-root widgets). Non-root widgets usually use appendChild and insertBefore to attach to the DOM tree[1]
If the DOM element doesn't exist, you can use jq.before or jq.after instead.
Notice that, both replaceHTML fires the beforeSize and onSize watch events (refer to zWatch).
If skipper is null. It implies the caller has to fire these two events if it specifies a skipper (that is how rerender is implemented).
the DOM element (DOMElement) or anything Widget.$ allowed.
Optional desktop: Desktopthe desktop that this widget shall belong to. If omitted, it is retrieve from the current desktop. If null, it is decided automatically ( such as the current value of desktop or the first desktop)
Optional skipper: Skipperit is used only if it is called by rerender
Optional _trim_: booleanOptional _callback_: CallableFunction[]Replaces this widget with the specified one. The parent and siblings of this widget will become the parent and siblings of the specified one.
Notice that replaceHTML is used to replace a DOM element that usually doesn't not belong to any widget. And, replaceWidget is used to replace the widget, and it maintains both the widget tree and the DOM tree.
Re-renders the DOM element(s) of this widget. By re-rendering we mean to generate HTML again (redraw) and then replace the DOM elements with the new generated HTML code snippet.
It is equivalent to replaceHTML(this.node, null, skipper).
It is usually used to implement a setter of this widget. For example, if a setter (such as `setBorder`) has to modify the visual appearance, it can update the DOM tree directly, or it can call this method to re-render all DOM elements associated with is widget and its descendants.
It is convenient to synchronize the widget's state with the DOM tree with this method. However, it shall be avoided if the HTML code snippet is complex (otherwise, the performance won't be good).
If re-rendering is required, you can improve the performance by passing an instance of zk.Skipper that is used to re-render some or all descendant widgets of this widget.
Optional skipper: Skipperskip some portion of this widget to speed up the re-rendering. If not specified, rerender(0) is assumed (since ZK 6).
Re-renders after the specified time (milliseconds).
Notice that, to have the best performance, we use the single timer to handle all pending rerenders for all widgets. In other words, if the previous timer is not expired (and called), the second call will reset the expiration time to the value given in the second call.
Optional timeout: numberthe number milliseconds (non-negative) to wait before rerender. If negative, it means rerender shall take place immediately. If not specified, 0 is assumed (since ZK 6).
5.0.4
A function that postpones the invoke of rerender function until all the cmds from server are processed. This avoids rerendering twice or more. It works only in the setAttrs phase, otherwise rerender will be invoked immediately.
Optional skipper: Skipper8.6.0
Sends an AU request to the server. It is invoked when fire will send an AU request to the server.
Override Notice: sendAU_ will call evt.target's beforeSendAU_ to give the original target a chance to process it.
the event that will be sent to the server.
the delay before really sending out the AU request
Sets a property. The property updates sent from the server, including renderProperties and smartUpdate, will invoke this method.
If the name starts with `on`, it is assumed to be an event listener and setListener will be called.
If the name starts with `$on`, the value is assumed to be a boolean indicating if the server registers a listener.
If the name starts with `$$on`, it indicates the event is an important event that the client must send it back to the server. In additions, the value is assumed to be a boolean indicating if the server registers a listener.
If the value is in this format, it indicates `$u`'s value is UUID of a widget, and it will be resolved to a widget before calling the real method.
However, since we cannot resolve a widget by its UUID until the widget is bound (to DOM). Thus, ZK sets property after mounted. For example, `wgt.set("radiogroup", {$u: uuid})` is equivalent to the following. ```js zk.afterMount(function () { wgt.set("radiogroup", zk.Widget.$(uuid)) }); ```
the name of property.
the value
Sets a property. The property updates sent from the server, including renderProperties and smartUpdate, will invoke this method.
the name of property. Refer to (set:TWO_PARAMS) for special names.
the value
the extra argument. It could be anything.
Sets the client-side action.
Optional action: stringthe client-side action
null (no CSA at all)
The format:
`action1: action-effect1; action2: action-effect2`
Currently, only two actions are `show` and `hide`. They are called when the widget is becoming visible (show) and invisible (hide).
The action effect (`action-effect1`) is the name of a method defined in zk.eff.Actions, such as `show: slideDown; hide: slideUp`
5.0.6
Sets whether to automatically complete this text box by matching the nearest item (Comboitem.
Sets the constraint.
null (means no constraint all all).
Sets the ID of the popup (zul.wgt.Popup) that should appear when the user right-clicks on the element (aka., context menu).
the ID of the popup widget.
Sets the ID of the popup (zul.wgt.Popup) that should appear when the user right-clicks on the element (aka., context menu).
An onOpen event is sent to the context menu if it is going to appear. Therefore, developers can manipulate it dynamically (perhaps based on OpenEvent.getReference) by listening to the onOpen event.
Note: To simplify the use, it not only searches its ID space, but also all ID spaces in the desktop. It first searches its own ID space, and then the other Id spaces in the same browser window (might have one or multiple desktops).
If there are two components with the same ID (of course, in
different ID spaces), you can specify the UUID with the following
format:
`uuid(comp_uuid)`
Example:
```ts
wgt.setContext('an_id');
wgt.setContext('uuid(an_uuid)');
wgt.setContext(a_wgt);
```
Both reference a component whose ID is "some".
But, if there are several components with the same ID,
the first one can reference to any of them.
And, the second one reference to the component in the same ID space
(of the label component).
The context menu can be shown by a position from zul.wgt.Popup.open or the location of `x` and `y`, you can specify the following format:
the popup widget.
Sets what keystrokes to intercept.
The string could be a combination of the following:
For example,
Changes the visibility of a child DOM content of this widget. It is called by setVisible to really change the visibility of the associated DOM elements.
whether to make it visible
Optional opts: DomVisibleOptionsthe options.
If omitted, {display:true} is assumed. Allowed value:
change n.style.display directly.
Sets the identifier of a draggable type for this widget.
Optional draggable: string | boolean"false", "" or null to denote non-draggable; "true" for draggable with anonymous identifier; others for an identifier of draggable.
null
The simplest way to make a widget draggable is to set this property to "true". To disable it, set this to "false" (or null). If there are several types of draggable objects, you could assign an identifier for each type of draggable object. The identifier could be anything but empty and "false".
Sets the identifier, or a list of identifiers of a droppable type for this widget.
Optional droppable: string | booleanfalse, null or "" to denote not-droppable; true for accepting any draggable types; a list of identifiers, separated by comma for identifiers of draggables this widget accept (to be dropped in).
null
The simplest way to make a component droppable is to set this attribute to `true`. To disable it, set this to `false` (or `null`).
If there are several types of draggable objects and this widget accepts only some of them, you could assign a list of identifiers that this widget accepts, separated by comma.
For example, if this component accepts dg1 and dg2, then assign "dg1, dg2" to this attribute.
Optional isFlexMin: booleanOptional isFlexMin: booleanSets the z-index for a floating widget. It is called by setTopmost to set the z-index, and called only if setFloating_ is ever called.
the element whose z-index needs to be set.
It is the value specified in opts.node when setFloating_
is called. If not specified, it is the same as Widget.$n.
the z-index to set
Sets a status to indicate if this widget is floating.
Notice that it doesn't change the DOM tree. It is caller's job. In the other words, the caller have to adjust the style by assigning `position` with `absolute` or `relative`.
whether to make it floating
Optional opts: Partial<{ The options. Allowed options:
Sets horizontal flexibility hint of this widget.
The parameter flex is a number in String type indicating how this widget's parent container distributes remaining empty space among its children widget horizontally. Flexible widget grow and shrink to fit their given space. Flexible widget with larger flex values will be made larger than widget with lower flex values, at the ratio determined by all flexible widgets. The actual flex value is not relevant unless there are other flexible widget within the same parent container. Once the default sizes of widget in a parent container are calculated, the remaining space in the parent container is divided among the flexible widgets, according to their flex ratios.
Specify a flex value of negative value, 0, or "false" has the same effect as leaving this flex attribute out entirely. Specify a flex value of "true" has the same effect as a flex value of 1.
Special flex hint, "min", indicates that the minimum space shall be given to this flexible widget to enclose all of its children widgets. That is, the flexible widget grow and shrink to fit its children widgets.
Optional hflex: string | booleanthe horizontal flex hint.
Sets some additional attributes to the input html tag in the component. this will only reset the additional attributes that are set by this method.
Optional opts: Record<string, boolean>8.6.1
Sets the instantSelect attribute. When the attribute is true, onSelect event will be fired as soon as user selects using keyboard navigation.
If the attribute is false, user needs to press Enter key to finish the selection using keyboard navigation.
8.6.1
Sets a listener that can be unlistened easily. It is designed to be called from server. For client-side programming, it is suggested to use listen.
It is based listen, but, unlike listen, the second invocation for the same event will unlisten the previous one automatically.
In additions, if the function (specified in the second element of inf) is null, it unlistens the previous invocation.
Sets a listener It is designed to be called from server. For client-side programming, it is suggested to use listen. Use it only if you want to unlisten the listener registered at the server (by use of the client namespace).
It is based listen, but, unlike listen, the second invocation for the same event will unlisten the previous one automatically.
In additions, if fn is null, it unlistens the previous invocation.
the listener function. If null, it means unlisten.
Sets the listener a map of listeners. It is similar to listen, except
This method is mainly designed to be called by the application running at the server.
Example: ```ts wgt.setListeners({ onChange: function (event) {this.doSomething();}, onFocus: 'this.doMore();', onBlur: null //unlisten }); ```
Sets the name of this component.
Don't use this method if your application is purely based on ZK's event-driven model.
The name is used only to work with "legacy" Web application that handles user's request by servlets. It works only with HTTP/HTML-based browsers. It doesn't work with other kind of clients.
the name of this component.
Optional opts: Record<string, boolean>Sets the ID of the popup (zul.wgt.Popup) that should appear when the user clicks on the element.
the ID of the popup widget.
Sets the ID of the popup (zul.wgt.Popup) that should appear when the user clicks on the element.
An onOpen event is sent to the popup menu if it is going to appear. Therefore, developers can manipulate it dynamically (perhaps based on OpenEvent.getReference) by listening to the onOpen event.
Note: To simplify the use, it not only searches its ID space, but also all ID spaces in the desktop. It first searches its own ID space, and then the other Id spaces in the same browser window (might have one or multiple desktops).
If there are two components with the same ID (of course, in
different ID spaces), you can specify the UUID with the following
format:
`uuid(comp_uuid)`
Example:
```ts
wgt.setPopup('an_id');
wgt.setPopup('uuid(an_uuid)');
wgt.setPopup(a_wgt);
```
Both reference a component whose ID is "some".
But, if there are several components with the same ID,
the first one can reference to any of them.
And, the second one reference to the component in the same ID space
(of the label component).
The popup menu can be shown by a position from zul.wgt.Popup.open or the location of `x` and `y`, you can specify the following format:
the popup widget.
Sets the width of the popup of this component If the input is a percentage, the popup width will be calculated by multiplying the width of this component with the percentage. (e.g. if the input string is 130%, and the width of this component is 300px, the popup width will be 390px = 300px * 130%) Others will be set directly.
of the popup of this component
Optional opts: Record<string, boolean>8.0.3
Sets the number of milliseconds before rendering this component at the client.
time to wait in milliseconds before rendering. Notice: 0 also implies deferring the rendering (just right after all others are rendered).
-1 (don't wait).
This method is useful if you have a sophisticated page that takes long to render at a slow client. You can specify a non-negative value as the render-defer delay such that the other part of the UI can appear earlier. The styling of the render-deferred widget is controlled by a CSS class called `z-render-defer`.
Notice that it has no effect if the component has been rendered at the client.
5.0.2
Sets the CSS class of this widget.
the style class
null
The default styles of ZK components doesn't depend on sclass at all. Rather, setSclass is provided to perform small adjustment, e.g., changing only the font size. In other words, the default style is still applied if you change sclass.
To replace the default style completely, use setZclass instead.
The real CSS class is a concatenation of getZclass and getSclass.
Sets the ID of the popup (zul.wgt.Popup) that should be used as a tooltip window when the mouse hovers over the element for a moment.
the ID of the popup widget.
Sets the ID of the popup (zul.wgt.Popup) that should be used as a tooltip window when the mouse hovers over the element for a moment.
An onOpen event is sent to the tooltip if it is going to appear. Therefore, developers can manipulate it dynamically (perhaps based on OpenEvent.getReference) by listening to the onOpen event.
Note: To simplify the use, it not only searches its ID space, but also all ID spaces in the desktop. It first searches its own ID space, and then the other Id spaces in the same browser window (might have one or multiple desktops).
If there are two components with the same ID (of course, in
different ID spaces), you can specify the UUID with the following
format:
`uuid(comp_uuid)`
Example:
```ts
wgt.setTooltip('an_id');
wgt.setTooltip('uuid(an_uuid)');
wgt.setTooltip(a_wgt);
```
Both reference a component whose ID is "some".
But, if there are several components with the same ID,
the first one can reference to any of them.
And, the second one reference to the component in the same ID space
(of the label component).
The tooltip can be shown by a position from zul.wgt.Popup.open or the location of `x` and `y`, and can be specified with a delay time (in millisecond), you can specify the following format:
Sets the top of this widget.
If you want to specify bottom, use setStyle instead.
For example, setStyle("bottom: 0px");
the top. Remember to specify 'px', 'pt' or '%'. An empty or null value means "auto"
Makes this widget as topmost.
If this widget is not floating, this method will look for its ancestors for the first ancestor who is floating. In other words, this method makes the floating containing this widget as topmost. To make a widget floating, use setFloating_.
This method has no effect if it is not bound to the DOM tree, or none of the widget and its ancestors is floating.
Notice that it does not fire onFloatUp so it is caller's job if it is necessary to close other popups.
the new value of z-index of the topmost floating window, -1 if this widget and none of its ancestors is floating or not bound to the DOM tree.
Sets the value in the String format(assumes no locale issue).
Notice that the invocation of getValue won't fire the onChange event. To fire it, you have to invoke fireOnChange explicitly.
the value.
Optional fromServer: booleanwhether it is called from the server. The error message will be cleared if true
Sets vertical flexibility hint of this widget.
The parameter flex is a number in String type indicating how this widget's parent container distributes remaining empty space among its children widget vertically. Flexible widget grow and shrink to fit their given space. Flexible widget with larger flex values will be made larger than widget with lower flex values, at the ratio determined by all flexible widgets. The actual flex value is not relevant unless there are other flexible widget within the same parent container. Once the default sizes of widget in a parent container are calculated, the remaining space in the parent container is divided among the flexible widgets, according to their flex ratios.
Specify a flex value of negative value, 0, or "false" has the same effect as leaving the flex attribute out entirely. Specify a flex value of "true" has the same effect as a flex value of 1.
Special flex hint, "min", indicates that the minimum space shall be given to this flexible widget to enclose all of its children widgets. That is, the flexible widget grow and shrink to fit its children widgets.
Optional vflex: string | booleanthe vertical flex hint.
Sets whether this widget is visible.
whether to be visible
Sets the Z index.
the Z index to assign to
if opts.fire is specified the onZIndex event will be triggered. If opts.floatZIndex is false, represent it is not from setFloatZIndex, so the userZIndex may be true.
Sets the ZK Cascading Style class(es) for this widget. It is the CSS class used to implement a mold of this widget. n implementation It usually depends on the implementation of the mold (getMold).
the style class used to apply the whole widget.
null
but an implementation usually provides a default class, such as z-button.
Calling setZclass with a different value will completely replace the default style of a widget. Once you change it, all default styles are gone. If you want to perform small adjustments, use setSclass instead.
The real CSS class is a concatenation of getZclass and getSclass.
whether a new child shall be ROD.
return true if child.z_rod or this.z_rod
5.0.1
Smart-updates a property of the peer component associated with this widget, running at the server, with the specified value.
It is actually fired an AU request named `setAttr`, and it is handled by the `updateByClient` method in `org.zkoss.zk.ui.AbstractComponent` (at the server).
By default, it is controlled by a component attribute called `org.zkoss.zk.ui.updateByClient`. And, it is default to false. Thus, the component developer has to override `updateByClient` at the server (in Java) and then update it rather than calling back superclass. For example, ```ts void updateByClient(String name, Object value) { if ("disabled".equals(name)) setDisabled(value instanceof Boolean && ((Boolean)value).booleanValue()); else super.updateByClient(name, value); } ```
the property name
the property value
Optional timeout: numberthe delay before sending out the AU request. It is optional. If omitted, -1 is assumed (i.e., it will be sent with next non-deferrable request).
A callback called after a child has been added to this widget for shadow host.
the child being added
10.0.0
A callback called after a child has been removed to this widget for shadow host.
the child being removed
10.0.0
A callback called before removing a child for shadow host.
the child being removed.
10.0.0
Unbinds this widget. It is called to remove the association (aka., detach) the widget from the DOM tree.
Notice that you rarely need to invoke this method, since it is called automatically (such as replaceHTML).
Notice that you rarely need to override this method, either. Rather, override unbind_ instead.
Undo the visual effect created by cloneDrag_.
the draggable controller
Removes a listener from the specified event.
wgt.unlisten({
onClick: wgt,
onOpen: wgt._onOpen,
onMove: [o, o._onMove]
});
a map of event listeners. Each key is the event name, and each value can be the target, the listener function, or a two-element array, where the first element is the target and the second the listener function.
Updates the DOM element's CSS class. It is called when the CSS class is changed (e.g., setZclass is called).
it changes the class of {@link Widget.$n}.
<h3>Subclass Note</h3>
<ul>
<li>Override it if the class has to be copied to DOM elements other than {@link Widget.$n}.</li>
</ul>
Updates the DOM element's style. It is called when the CSS style is changed (e.g., setStyle is called).
it changes the CSS style of {@link Widget.$n}.
<h3>Subclass Note</h3>
<ul>
<li>Override it if the CSS style has to be copied to DOM elements other than {@link Widget.$n}.</li>
</ul>
Synchronizes a map of objects that are associated with this widget, and they shall be resized when the size of this widget is changed.
It is useful to sync the layout, such as shadow, mask and error message, that is tightly associated with a widget.
Optional opts: ZKObjectthe options, or undefined if none of them specified.
Allowed values:
Static $Retrieves the widget.
Optional n: null | string | Node | JQuery<HTMLElement> | Event | Event<unknown> | Tthe object to look for. If it is a string,
it is assumed to be UUID, unless it starts with '$'.
For example, zk.Widget.$('uuid') is the same as zk.Widget.$('#uuid'),
and both look for a widget whose ID is 'uuid'. On the other hand,
zk.Widget.$('$id') looks for a widget whose ID is 'id'.
and zk.Widget.$('.className') looks for a widget whose CSS selector is 'className'. (since zk 8.0)
If it is an DOM element (DOMElement), it will look up
which widget it belongs to.
If the object is not a DOM element and has a property called
target, then target is assumed.
Thus, you can pass an instance of jq.Event or zk.Event,
and the target widget will be returned.
Optional opts: Partial<{ the options. Allowed values:
Static disableStatic enableStatic getStatic getStatic getthe widget name widgetName.
all DOMElement with the given widget name.
5.0.2
Static getStatic getStatic isDetermines if the class by this Class object is either the same as, or is a superclass of, the class represented by the specified Class parameter. Example:
if (klass1.isAssignableFrom(klass2)) {
}
the Class object to be checked, such as zk.Widget.
true if assignable
Static isStatic isDetermines if the specified Object is assignment-compatible with this Class. This method is equivalent to [[zk.Object#$instanceof]. Example:
if (klass.isInstance(obj)) {
}
the object to check
true if the object is an instance
Static newCreates a widget by specifying the widget name. The widget name is the last part of the class name of a widget (and converting the first letter to lower case). For example, if a widget's class name is zul.inp.Textbox, then the widget name is textbox.
This method is usually used by tools, such as zk.zuml.Parser, rather than developers, since developers can create the widget directly if he knows the class name.
the widget name, such as textbox.
Optional props: Record<string, unknown>the properties that will be passed to Widget.$init.
Static nextthe next unique UUID for a widget. The UUID is unique in the whole browser window and does not conflict with the peer component's UUID.
This method is called automatically if Widget.$init is called without uuid.
Static registerRegisters a widget class. It is called automatically if the widget is loaded by WPD loader, so you rarely need to invoke this method. However, if you create a widget class at run time, you have to call this method explicitly. Otherwise, className, getClass, and newInstance won't be applicable.
Notice that the class must be declared before calling this method. In other words, zk.$import(clsnm) must return the class of the specified class name. ```ts zk.Widget.register('foo.Cool'); //class name zk.Widget.getClass('cool'); //widget name ```
the class name, such as zul.wnd.Window
Static uuid
A combobox.
Non-XUL extension. It is used to replace XUL menulist. This class is more flexible than menulist, such as setAutocomplete setAutodrop.
Default Value
See
Comboitem