Package org.zkoss.zk.ui.impl

## Class UiEngineImpl

- java.lang.Object
- - org.zkoss.zk.ui.impl.UiEngineImpl

- All Implemented Interfaces:
    `UiEngine`

      public class UiEngineImpl
      extends java.lang.Object
      implements UiEngine

  An implementation of `UiEngine` to create and update components.
  Author:
    tomyeh

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static interface` | `UiEngineImpl.Extension` | An interface used to extend the UI engine.

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `UiEngineImpl()` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `activate​(Execution exec)` | Activates an execution such that you can access a component.
    `boolean` | `activate​(Execution exec, int timeout)` | Activates an execution such that you can access a component.
    `void` | `addInvalidate​(Component comp)` | Invalidates a component to cause redrawing.
    `void` | `addInvalidate​(Page page)` | Invalidates the page to cause all of its components to redraw.
    `void` | `addMoved​(Component comp, Component oldparent, Page oldpg, Page newpg)` | Called to update (redraw) a component, when a component is moved.
    `void` | `addResponse​(java.lang.String key, AuResponse response)` | Adds a response which will be sent to client at the end of the execution.
    `void` | `addResponse​(java.lang.String key, AuResponse response, int priority)` | Adds a response with the given priority.
    `void` | `addResponse​(AuResponse response)` | Adds a response directly by using `AuResponse.getOverrideKey()` as the override key.
    `void` | `addSmartUpdate​(Component comp, java.lang.String attr, java.lang.Object value, boolean append)` | Smart-updates a property of the peer widget.
    `void` | `addSmartUpdate​(Component comp, java.lang.String attr, java.lang.Object value, int priority)` | Adds a smart update that will be executed at the given priority.
    `void` | `addUuidChanged​(Component comp)` | Called before changing the component's UUID.
    `protected void` | `afterRenderComponents​(java.util.Collection<Component> comps)` | Called when this engine renders the given components.
    `void` | `beginUpdate​(Execution exec)` | Activates and prepare for asynchronous update
    `boolean` | `ceaseSuspendedThread​(Desktop desktop, EventProcessingThread evtthd, java.lang.String cause)` | Ceases the specified event thread.
    `void` | `clearSmartUpdate​(Component comp)` | Clears all existing smart updates that belong to the given component.
    `void` | `closeUpdate​(java.lang.Object ctx)` | Deactivates the execution and cleans up.
    `Component[]` | `createComponents​(Execution exec, PageDefinition pagedef, Page page, Component parent, Component insertBefore, VariableResolver resolver, java.util.Map<?,​?> arg)` | Creates components from the specified page and definition.
    `void` | `deactivate​(Execution exec)` | Deactivates an execution, such that other threads could activate and access components.
    `void` | `desktopDestroyed​(Desktop desktop)` | Called when a desktop is being removed.
    `boolean` | `disableClientUpdate​(Component comp, boolean disable)` | Sets whether to disable the update of the client widget.
    `void` | `endUpdate​(Execution exec)` | Executes posted events, deactivate and ends the asynchronous update.
    `void` | `execNewPage​(Execution exec, PageDefinition pagedef, Page page, java.io.Writer out)` | Creates components specified in the given page definition.
    `void` | `execNewPage​(Execution exec, Richlet richlet, Page page, java.io.Writer out)` | Invoke `Richlet.service(org.zkoss.zk.ui.Page)`, when a new page is creates upon visiting a richlet.
    `void` | `execRecover​(Execution exec, FailoverManager failover)` | Executes the recovering.
    `void` | `execUpdate​(Execution exec, java.util.List<AuRequest> requests, AuWriter out)` | Executes an asynchronous update to a component (or page).
    `JSONArray` | `finishUpdate​(java.lang.Object ctx)` | Finishes the update and returns the result in an array of JSON object.
    `JSONArray` | `finishUpdate​(java.lang.Object ctx, java.util.List<java.lang.Throwable> errs)` | Finishes the update and returns the result in an array of JSON object.
    `java.lang.String` | `getNativeContent​(Component comp, java.util.List<NodeInfo> children, Native.Helper helper)` | Retrieve the native content for a property of the specified component.
    `java.util.Collection<EventProcessingThread>` | `getSuspendedThreads​(Desktop desktop)` | Returns a collection of suspended event processing threads belonging to the specified desktop, or empty if no suspended thread at all.
    `boolean` | `hasSuspendedThread()` | Returns if any suspended event processing thread in the whole system.
    `boolean` | `isInvalidated​(Component comp)` | Returns if this component needs to be redrawn.
    `void` | `notify​(java.lang.Object mutex)` | Wakes up a single event processing thread that is waiting on the specified object.
    `void` | `notify​(Desktop desktop, java.lang.Object mutex)` | Wakes up a single event processing thread for the specified desktop that is waiting on the specified object.
    `void` | `notifyAll​(java.lang.Object mutex)` | Wakes up all event processing thread that are waiting on the specified object.
    `void` | `notifyAll​(Desktop desktop, java.lang.Object mutex)` | Wakes up all event processing threads for the specified desktop that are waiting on the specified object.
    `void` | `recycleDesktop​(Execution exec, Page page, java.io.Writer out)` | Reuse the desktop and generate the output.
    `void` | `sendRedirect​(java.lang.String uri, java.lang.String target)` | Sends a temporary redirect response to the client using the specified redirect location URL.
    `void` | `setAbortingReason​(AbortingReason aborting)` | Aborts the current execution.
    `Component` | `setOwner​(Component comp)` | Called before a component redraws itself if the component might include another page.
    `void` | `start​(WebApp wapp)` | Starts the engine.
    `java.lang.Object` | `startUpdate​(Execution exec)` | Activates an execution that will allow developers to update the state of components.
    `void` | `stop​(WebApp wapp)` | Stops the engine.
    `void` | `wait​(java.lang.Object mutex)` | Suspends the current processing of an event and wait until the other thread invokes `UiEngine.notify(Object)`, `UiEngine.notifyAll(Object)`, `UiEngine.notify(Desktop, Object)` or `UiEngine.notifyAll(Desktop, Object)` for the specified object.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### UiEngineImpl

          public UiEngineImpl()

  - ### Method Detail

    - #### start

          public void start​(WebApp wapp)

      Description copied from interface: `UiEngine`
      Starts the engine.
      Specified by:
        `start` in interface `UiEngine`

    - #### stop

          public void stop​(WebApp wapp)

      Description copied from interface: `UiEngine`
      Stops the engine. Called only if the server is about to stop.
      Specified by:
        `stop` in interface `UiEngine`

    - #### hasSuspendedThread

          public boolean hasSuspendedThread()

      Description copied from interface: `UiEngine`
      Returns if any suspended event processing thread in the whole system.
      Specified by:
        `hasSuspendedThread` in interface `UiEngine`

    - #### getSuspendedThreads

          public java.util.Collection<EventProcessingThread> getSuspendedThreads​(Desktop desktop)

      Description copied from interface: `UiEngine`
      Returns a collection of suspended event processing threads belonging to the specified desktop, or empty if no suspended thread at all.

      An event processing thread is an instance of `EventProcessingThread`

      Specified by:
        `getSuspendedThreads` in interface `UiEngine`
      Parameters:
        `desktop` - the desktop that the suspended event processing threads belong to (never null).

    - #### ceaseSuspendedThread

          public boolean ceaseSuspendedThread​(Desktop desktop,
                                              EventProcessingThread evtthd,
                                              java.lang.String cause)

      Description copied from interface: `UiEngine`
      Ceases the specified event thread.
      Specified by:
        `ceaseSuspendedThread` in interface `UiEngine`
      Parameters:
        `desktop` - which desktop the event thread belongs to
        `cause` - an arbitrary text to describe the cause. It will be the message of the thrown InterruptedException.
      Returns:
        true if the event processing thread is ceased successfully; false if no such thread or it is not suspended.

    - #### desktopDestroyed

          public void desktopDestroyed​(Desktop desktop)

      Description copied from interface: `UiEngine`
      Called when a desktop is being removed.

      Application developers don't need to remove pages and desktops. They are removed and cleaned up automatically.

      Specified by:
        `desktopDestroyed` in interface `UiEngine`

    - #### setOwner

          public Component setOwner​(Component comp)

      Description copied from interface: `UiEngine`
      Called before a component redraws itself if the component might include another page.

      If a new page is created, the specified component will become the owner of the new page.

      It must reset the owner in the finally clause.

          old = ue.setOwner(this);
          try{
            ...
          } finally {
            ue.setOwner(old);
          }

      Since 5.0.6, the owner must implement `Includer`.

      Specified by:
        `setOwner` in interface `UiEngine`
      Returns:
        the previous owner

    - #### isInvalidated

          public boolean isInvalidated​(Component comp)

      Description copied from interface: `UiEngine`
      Returns if this component needs to be redrawn.

      Note:

      1. It always returns true if the current execution is not an asynchronous update.
      2. If its parent is invalidated, this component will be redrawn too, but this method returns false since `UiEngine.addInvalidate(Component)` was not called against this component.
      Specified by:
        `isInvalidated` in interface `UiEngine`

    - #### addInvalidate

          public void addInvalidate​(Page page)

      Description copied from interface: `UiEngine`
      Invalidates the page to cause all of its components to redraw.
      Specified by:
        `addInvalidate` in interface `UiEngine`

    - #### addInvalidate

          public void addInvalidate​(Component comp)

      Description copied from interface: `UiEngine`
      Invalidates a component to cause redrawing. Called when `Component.invalidate()` is called.
      Specified by:
        `addInvalidate` in interface `UiEngine`

    - #### addSmartUpdate

          public void addSmartUpdate​(Component comp,
                                     java.lang.String attr,
                                     java.lang.Object value,
                                     boolean append)

      Description copied from interface: `UiEngine`
      Smart-updates a property of the peer widget.
      Specified by:
        `addSmartUpdate` in interface `UiEngine`
        `append` - whether to append the updates of properties with the same name. If false, only the last value of the same property will be sent to the client.

    - #### addSmartUpdate

          public void addSmartUpdate​(Component comp,
                                     java.lang.String attr,
                                     java.lang.Object value,
                                     int priority)

      Description copied from interface: `UiEngine`
      Adds a smart update that will be executed at the given priority. The higher priority, the earlier the update is executed. If `UiEngine.addSmartUpdate(Component, String, Object, boolean)` is invoked, the priority is assumed to 0.

      If the priority is the same, the update is executed in the order of first-in-first out. You rarely need to control the sequence, unless the update is used to instantiate client-side widgets that other updates might depend on. In this case, it is suggested to specify the priority as 10000 (and not to use priority higher than 10000 for other situation).

      Specified by:
        `addSmartUpdate` in interface `UiEngine`

    - #### clearSmartUpdate

          public void clearSmartUpdate​(Component comp)

      Description copied from interface: `UiEngine`
      Clears all existing smart updates that belong to the given component.
      Specified by:
        `clearSmartUpdate` in interface `UiEngine`

    - #### addResponse

          public void addResponse​(AuResponse response)

      Description copied from interface: `UiEngine`
      Adds a response directly by using `AuResponse.getOverrideKey()` as the override key. In other words, it is the same as `addResponse(resposne.getOverrideKey(), response)`

      If the response is component-dependent, `AuResponse.getDepends()` must return a component. And, if the component is removed, the response is removed, too.

      Specified by:
        `addResponse` in interface `UiEngine`
      See Also:
        `UiEngine.addResponse(String, AuResponse)`

    - #### addResponse

          public void addResponse​(java.lang.String key,
                                  AuResponse response)

      Description copied from interface: `UiEngine`
      Adds a response which will be sent to client at the end of the execution. Called by `AbstractComponent.response(org.zkoss.zk.au.AuResponse)`.

      Note: `Execution.addAuResponse(org.zkoss.zk.au.AuResponse)` is a shortcut to this method, and it is used by application developers.

      If `AuResponse.getDepends()` is not null, the response depends on the returned component. In other words, the response is removed if the component is removed. If it is null, the response is component-independent.

      Specified by:
        `addResponse` in interface `UiEngine`
      Parameters:
        `key` - could be anything. If null, the response is appended. If not null, the second invocation of this method in the same execution with the same key and the same depends (`AuResponse.getDepends()`) will override the previous one.
      See Also:
        `UiEngine.addResponse(AuResponse)`

    - #### addResponse

          public void addResponse​(java.lang.String key,
                                  AuResponse response,
                                  int priority)

      Description copied from interface: `UiEngine`
      Adds a response with the given priority. The higher priority, the earlier the update is executed. The priority of `UiEngine.addResponse(String, AuResponse)` and `UiEngine.addResponse(AuResponse)` is assumed to be 0.

      If the priority is the same, the update is executed in the order of first-in-first out.

      Specified by:
        `addResponse` in interface `UiEngine`

    - #### addMoved

          public void addMoved​(Component comp,
                               Component oldparent,
                               Page oldpg,
                               Page newpg)

      Description copied from interface: `UiEngine`
      Called to update (redraw) a component, when a component is moved. If a component's page or parent is changed, this method need to be called only once for the top one.
      Specified by:
        `addMoved` in interface `UiEngine`
        `oldparent` - the parent before moved
        `oldpg` - the page before moved
        `newpg` - the page after moved

    - #### addUuidChanged

          public void addUuidChanged​(Component comp)

      Description copied from interface: `UiEngine`
      Called before changing the component's UUID.
      Specified by:
        `addUuidChanged` in interface `UiEngine`

    - #### disableClientUpdate

          public boolean disableClientUpdate​(Component comp,
                                             boolean disable)

      Description copied from interface: `UiEngine`
      Sets whether to disable the update of the client widget. By default, if a component is attached to a page, modifications that change the visual representation will be sent to the client to ensure the consistency.
      Specified by:
        `disableClientUpdate` in interface `UiEngine`
      Returns:
        whether it has been disabled before this invocation, i.e., the previous disable status

    - #### execNewPage

          public void execNewPage​(Execution exec,
                                  Richlet richlet,
                                  Page page,
                                  java.io.Writer out)
                           throws java.io.IOException

      Description copied from interface: `UiEngine`
      Invoke `Richlet.service(org.zkoss.zk.ui.Page)`, when a new page is creates upon visiting a richlet.
      Specified by:
        `execNewPage` in interface `UiEngine`
      Throws:
        `java.io.IOException`

    - #### execNewPage

          public void execNewPage​(Execution exec,
                                  PageDefinition pagedef,
                                  Page page,
                                  java.io.Writer out)
                           throws java.io.IOException

      Description copied from interface: `UiEngine`
      Creates components specified in the given page definition. Called when a new page is creates.
      Specified by:
        `execNewPage` in interface `UiEngine`
      Throws:
        `java.io.IOException`

    - #### recycleDesktop

          public void recycleDesktop​(Execution exec,
                                     Page page,
                                     java.io.Writer out)
                              throws java.io.IOException

      Description copied from interface: `UiEngine`
      Reuse the desktop and generate the output.
      Specified by:
        `recycleDesktop` in interface `UiEngine`
      Throws:
        `java.io.IOException`

    - #### afterRenderComponents

          protected void afterRenderComponents​(java.util.Collection<Component> comps)

      Called when this engine renders the given components.
      Parameters:
        `comps` - the collection of components that have been redrawn.

    - #### createComponents

          public Component[] createComponents​(Execution exec,
                                              PageDefinition pagedef,
                                              Page page,
                                              Component parent,
                                              Component insertBefore,
                                              VariableResolver resolver,
                                              java.util.Map<?,​?> arg)

      Description copied from interface: `UiEngine`
      Creates components from the specified page and definition. It can be called when `UiEngine.execNewPage(org.zkoss.zk.ui.Execution, org.zkoss.zk.ui.metainfo.PageDefinition, org.zkoss.zk.ui.Page, java.io.Writer)` or `UiEngine.execUpdate(org.zkoss.zk.ui.Execution, java.util.List<org.zkoss.zk.au.AuRequest>, org.zkoss.zk.au.AuWriter)` was called. It assumes the execution is already locked to this desktop.

      Note: if both page and parent are null, the created components don't belong to any page/parent.

      Specified by:
        `createComponents` in interface `UiEngine`
      Parameters:
        `exec` - the execution (never null).
        `pagedef` - the page definition (never null).
        `page` - the page. Ignored if parent is specified and parent's page is not null (parent's page will be used). If both page and parent are null, the created components won't belong to any page.
        `parent` - the parent component, or null if no parent component. If parent is specified, page is ignored.
        `insertBefore` - the sibling component that new components will be inserted before. Ignored if null (i.e., append as last children).
        `resolver` - the variable resolver used to resolve variables. Ignored if null.
        `arg` - a map of parameters that is accessible by the arg variable in EL, or by `Execution.getArg()`. Ignored if null.
      Returns:
        the components being created.

    - #### sendRedirect

          public void sendRedirect​(java.lang.String uri,
                                   java.lang.String target)

      Description copied from interface: `UiEngine`
      Sends a temporary redirect response to the client using the specified redirect location URL.

      After calling this method, the caller shall end the processing immediately (by returning). All pending requests and events will be dropped.

      Specified by:
        `sendRedirect` in interface `UiEngine`
      Parameters:
        `uri` - the URI to redirect to, or null to reload the same page
        `target` - the new target, or null to denote the same browser window

    - #### setAbortingReason

          public void setAbortingReason​(AbortingReason aborting)

      Description copied from interface: `UiEngine`
      Aborts the current execution. if not null, it means the current execution is aborting

      Note: if setAbortingReason is ever set with non-null, you CANNOT set it back to null.

      After call this method, you shall not keep processing the page because the rendering is dropped and the client is out-of-sync with the server.

      Specified by:
        `setAbortingReason` in interface `UiEngine`
      Parameters:
        `aborting` - the aborting reason.

    - #### execRecover

          public void execRecover​(Execution exec,
                                  FailoverManager failover)

      Description copied from interface: `UiEngine`
      Executes the recovering.
      Specified by:
        `execRecover` in interface `UiEngine`

    - #### beginUpdate

          public void beginUpdate​(Execution exec)

      Description copied from interface: `UiEngine`
      Activates and prepare for asynchronous update
      Specified by:
        `beginUpdate` in interface `UiEngine`

    - #### endUpdate

          public void endUpdate​(Execution exec)
                         throws java.io.IOException

      Description copied from interface: `UiEngine`
      Executes posted events, deactivate and ends the asynchronous update.
      Specified by:
        `endUpdate` in interface `UiEngine`
      Throws:
        `java.io.IOException`

    - #### execUpdate

          public void execUpdate​(Execution exec,
                                 java.util.List<AuRequest> requests,
                                 AuWriter out)
                          throws java.io.IOException

      Description copied from interface: `UiEngine`
      Executes an asynchronous update to a component (or page). It is the same as execUpdate(exec, requests, null, out).

      Note: the output must be XML and UTF-8.

      Specified by:
        `execUpdate` in interface `UiEngine`
        `requests` - a list of `AuRequest`.
      Throws:
        `java.io.IOException`

    - #### startUpdate

          public java.lang.Object startUpdate​(Execution exec)
                                       throws java.io.IOException

      Description copied from interface: `UiEngine`
      Activates an execution that will allow developers to update the state of components.

      It is designed to implement `Bridge`.

      Specified by:
        `startUpdate` in interface `UiEngine`
      Returns:
        a context that shall be passed to `UiEngine.finishUpdate(java.lang.Object)`.
      Throws:
        `java.io.IOException`
      See Also:
        `UiEngine.finishUpdate(java.lang.Object)`, `UiEngine.closeUpdate(java.lang.Object)`

    - #### finishUpdate

          public JSONArray finishUpdate​(java.lang.Object ctx)
                                 throws java.io.IOException

      Description copied from interface: `UiEngine`
      Finishes the update and returns the result in an array of JSON object. Notice it does not deactivate the execution. Rather, the caller has to invoke `UiEngine.closeUpdate(java.lang.Object)`.

      It is designed to implement `Bridge`.

      Specified by:
        `finishUpdate` in interface `UiEngine`
      Parameters:
        `ctx` - the context returned by the previous call to `UiEngine.startUpdate(org.zkoss.zk.ui.Execution)`
      Throws:
        `java.io.IOException`
      See Also:
        `UiEngine.startUpdate(org.zkoss.zk.ui.Execution)`, `UiEngine.closeUpdate(java.lang.Object)`

    - #### finishUpdate

          public JSONArray finishUpdate​(java.lang.Object ctx,
                                        java.util.List<java.lang.Throwable> errs)
                                 throws java.io.IOException

      Description copied from interface: `UiEngine`
      Finishes the update and returns the result in an array of JSON object. Notice it does not deactivate the execution. Rather, the caller has to invoke `UiEngine.closeUpdate(java.lang.Object)`.

      It is designed to implement `Bridge`.

      Specified by:
        `finishUpdate` in interface `UiEngine`
      Parameters:
        `ctx` - the context returned by the previous call to `UiEngine.startUpdate(org.zkoss.zk.ui.Execution)`
        `errs` - the collection of errors if any.
      Throws:
        `java.io.IOException`
      See Also:
        `UiEngine.finishUpdate(Object)`

    - #### closeUpdate

          public void closeUpdate​(java.lang.Object ctx)
                           throws java.io.IOException

      Description copied from interface: `UiEngine`
      Deactivates the execution and cleans up.

      It is designed to implement `Bridge`.

      Specified by:
        `closeUpdate` in interface `UiEngine`
      Throws:
        `java.io.IOException`
      See Also:
        `UiEngine.startUpdate(org.zkoss.zk.ui.Execution)`, `UiEngine.finishUpdate(java.lang.Object)`

    - #### wait

          public void wait​(java.lang.Object mutex)
                    throws java.lang.InterruptedException,
                           SuspendNotAllowedException

      Description copied from interface: `UiEngine`
      Suspends the current processing of an event and wait until the other thread invokes `UiEngine.notify(Object)`, `UiEngine.notifyAll(Object)`, `UiEngine.notify(Desktop, Object)` or `UiEngine.notifyAll(Desktop, Object)` for the specified object.

      It can only be called when the current thread is processing an event. And, when called, the current processing is suspended and ZK continues to process the next event and finally render the result.

      It is typical use to implement a modal dialog where it won't return until the modal dialog ends.

      Specified by:
        `wait` in interface `UiEngine`
      Parameters:
        `mutex` - any non-null object to identify what to wait, such that `UiEngine.notify(Object)` and `UiEngine.notify(Desktop, Object)` knows which object to notify.
      Throws:
        `SuspendNotAllowedException` - if there are too many suspended exceptions. Deployers can control the maximal allowed number of suspended exceptions by specifying `max-suspended-thread` in `zk.xml`, or invoking `Configuration.setMaxSuspendedThreads(int)`.
        `java.lang.InterruptedException`

    - #### notify

          public void notify​(java.lang.Object mutex)

      Description copied from interface: `UiEngine`
      Wakes up a single event processing thread that is waiting on the specified object.

      Unlike `UiEngine.notify(Desktop, Object)`, this method can be invoked only if the same desktop is locked for processing requests.

      Specified by:
        `notify` in interface `UiEngine`
      Parameters:
        `mutex` - any non-null object to identify what to notify. It must be same object passed to `UiEngine.wait(java.lang.Object)`.
      See Also:
        `UiEngine.notify(Desktop, Object)`, `UiEngine.notifyAll(Object)`

    - #### notify

          public void notify​(Desktop desktop,
                             java.lang.Object mutex)

      Description copied from interface: `UiEngine`
      Wakes up a single event processing thread for the specified desktop that is waiting on the specified object.

      Unlike `UiEngine.notify(Object)`, this method can be called any time. It is designed to let working threads resume an event processing thread.

      Notice: if this method is NOT called in an event processing thread, the resumed thread won't execute until the next request is received. To enforce it happen, you might use the timer component (found in ZUL).

      Specified by:
        `notify` in interface `UiEngine`
      Parameters:
        `desktop` - the desktop which the suspended thread is processing. It must be the same desktop of the suspended thread.
        `mutex` - any non-null object to identify what to notify. It must be same object passed to `UiEngine.wait(java.lang.Object)`.
      See Also:
        `UiEngine.notify(Object)`, `UiEngine.notifyAll(Desktop, Object)`

    - #### notifyAll

          public void notifyAll​(java.lang.Object mutex)

      Description copied from interface: `UiEngine`
      Wakes up all event processing thread that are waiting on the specified object.

      Unlike `UiEngine.notify(Desktop, Object)`, this method can be invoked only if the same desktop is locked for processing requests.

      Specified by:
        `notifyAll` in interface `UiEngine`
      Parameters:
        `mutex` - any non-null object to identify what to notify. It must be same object passed to `UiEngine.wait(java.lang.Object)`.
      See Also:
        `UiEngine.notify(Desktop, Object)`, `UiEngine.notifyAll(Object)`

    - #### notifyAll

          public void notifyAll​(Desktop desktop,
                                java.lang.Object mutex)

      Description copied from interface: `UiEngine`
      Wakes up all event processing threads for the specified desktop that are waiting on the specified object.

      Unlike `UiEngine.notifyAll(Object)`, this method can be called any time. It is designed to let working threads resume an event processing thread.

      If this method is NOT called in an event processing thread, the resumed thread won't execute until the next request is received. To enforce it happen, you might use the timer component (found in ZUL).

      Specified by:
        `notifyAll` in interface `UiEngine`
      Parameters:
        `desktop` - the desktop which the suspended thread is processing. It must be the same desktop of the suspended thread.
        `mutex` - any non-null object to identify what to notify. It must be same object passed to `UiEngine.wait(java.lang.Object)`.
      See Also:
        `UiEngine.notify(Object)`, `UiEngine.notifyAll(Desktop, Object)`

    - #### activate

          public void activate​(Execution exec)

      Description copied from interface: `UiEngine`
      Activates an execution such that you can access a component. You must call `UiEngine.deactivate(org.zkoss.zk.ui.Execution)` in the finally clause.

      Note: you RARELY need to invoke this method because `UiEngine.execNewPage(org.zkoss.zk.ui.Execution, org.zkoss.zk.ui.metainfo.PageDefinition, org.zkoss.zk.ui.Page, java.io.Writer)` and `UiEngine.execUpdate(org.zkoss.zk.ui.Execution, java.util.List<org.zkoss.zk.au.AuRequest>, org.zkoss.zk.au.AuWriter)` will activate and deactivate automatically.

      Note: this method can be called only when processing a client request (e.g., HTTP) other than creating a new page and processing async-update.

      Also, even if you use this method to grant the right to access components of the specified page, don't post events, create, remove, invalidate and do any smart updates. In other words, READ ONLY.

      Specified by:
        `activate` in interface `UiEngine`

    - #### activate

          public boolean activate​(Execution exec,
                                  int timeout)

      Description copied from interface: `UiEngine`
      Activates an execution such that you can access a component. Unlike `UiEngine.activate(Execution)`, you could specify an amount of time (timeout), and it returns false if it takes longer than the given amount of time before granted.
      Specified by:
        `activate` in interface `UiEngine`
        `timeout` - the number of milliseconds to wait before giving up. It is ignored if negative, i.e., it waits until granted if negative.
      Returns:
        whether the activation succeeds

    - #### deactivate

          public void deactivate​(Execution exec)

      Description copied from interface: `UiEngine`
      Deactivates an execution, such that other threads could activate and access components.
      Specified by:
        `deactivate` in interface `UiEngine`

    - #### getNativeContent

          public java.lang.String getNativeContent​(Component comp,
                                                   java.util.List<NodeInfo> children,
                                                   Native.Helper helper)

      Description copied from interface: `UiEngine`
      Retrieve the native content for a property of the specified component. The native content is a value of a property that is represented by a XML fragment (actually `NativeInfo`).

      Example:

          <html>
           <attribute name="content">
            <br/>
           </attribute>
          </html>

      Specified by:
        `getNativeContent` in interface `UiEngine`
      Parameters:
        `comp` - the component that the native content will be assigned to. It is the object that the self variable is assigned when evaluating EL expressions.
        `children` - a list of `NativeInfo`, `TextInfo` and others. This method evaluates them one-by-one and returns the result which is the value that will be assigned.
        `helper` - the helper used to generate the content.
      See Also:
        `Property`