the target widget.
the event name, such as onClick
Optional data: TDatathe data depending on the event.
Optional opts: EventOptionsthe options. Refer to opts
Optional domEvent: TriggeredEvent<any, any, any, any>the DOM event that causes this widget event.
The 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)
Indicates whether to stop the sending of the AU request to the server.
Optional charOptional contextOptional currentIndicates the target which is handling this event.
By default, an event will be propagated to its parent, and this member tells which widget is handling it, while #target is the widget that the event is targeting.
Optional dataThe data which depends on the event. Here is the list of Event Data.
Data can be any javascript Object. You can bring Number, String or JSON object to server side with it.
The javascript JSON object will be transfered to org.zkoss.json.JSONObject at server side as the following: ```ts // at client side var json = { "aa" : [{"a11":"11", "a12":12},{"a21":"21","a22":22.2}], "bb":[{"b11":"31","b12":"32"},{"b21":"41","b22":"42","b23":43}] }, data = {jsonObject:json};
// at server side final JSONObject jsonObject = (JSONObject)data.get("jsonObject"); // get JSONObject // will output "22.2" System.out.println(((JSONObject)((JSONArray)jsonObject.get("aa")).get(1)).get("a22")); // will output "class java.lang.Double" System.out.println(((JSONObject)((JSONArray)jsonObject.get("aa")).get(1)).get("a22").getClass());
<p>However, if data is an instance of Map, its content is copied to the event instance. Thus, you can access them directly with the event instance as follows.
```ts
onClick: function (evt) {
if (evt.altKey) { //it is the same as evt.data.altKey
}
}
Refer to ZK Client-side Reference: AU Requests: Server-side Processing.
Optional domThe DOM event that causes this widget event, or null if not available.
Indicates whether to stop the native DOM event.
The DOM element that the event is targeting, or null if not available.
Optional itemOptional keysThe event name, such as 'onChange'. The data which depends on the event. Here is the list of Event Data.
However, if data is an instance of Map, its content is copied to the event instance. Thus, you can access them directly with the event instance as follows. ```ts onClick: function (evt) { if (evt.altKey) { //it is the same as evt.data.altKey } } ```
The options (never null).
Allowed properties:
Indicates whether the event propagation is stopped.
The target widget (readonly).
Optional tooltippedStatic $oidDetermines 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
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.
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
Indicates whether a key is currently pressed. You can also pass more then one key into this method as a key combination, but combination only works with modifier keys(ALT/CONTROL/SHIFT/META). If you combine two(or more) keys that are not modifier keys, you will always get an exception since it is invalid. For example: isPressed(zKeys.CONTROL, zKeys.ALT, zKeys.ARROWDOWN) is valid. isPressed(zKeys.ARROWDOWN, zKeys.ARROWUP) is invalid.
Rest ...args: zKeys[]The target key and the modifier keys
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).
evt.stop();
evt.stop({propagation:true}); //stop only the event propagation (see below)
evt.stop({au:true}); //stop only the sending of the AU request
Stop the event propagation.
evt.stop();
evt.stop({propagation:true}); //stop only the event propagation (see below)
evt.stop({au:true}); //stop only the sending of the AU request
If you want to revoke the stop of the event propagation, you can specify `{revoke:true}` to the opts argument. ```ts evt.stop({progagation:true,revoke:true}); //revoke the event propagation ```
Notice that the event won't be sent to the server if stop() was called.
Optional opts: EventStopOptionscontrol what to stop. If omitted, the event propagation (stopped) and the native DOM event (domStopped) are both stopped (but not auStopped). For fine control, you can use a combination of the following values:
Static 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 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
The class representing a widget event (aka., a ZK event). A widget event is the widget-level event that a widget can fire and the client application can listen.
On the other hand, a DOM event (jq.Event) is the low-level event related to DOM elements. It is usually listened by the implementation of a widget, rather than the client application.
In additions, zWatch is an utility to manage the system-level events, and both the client application and the widget implementation might listen.
To fire a widget event, use zk.Widget#fire. To listen a widget event, use zk.Widget#listen.
See Also
Common Key Codes: