Interface ToolManager

  • All Known Implementing Classes:
    BasicToolManager

    public interface ToolManager
    Manages the viewer-/page-view-related client-side Tools.
    • Method Detail

      • register

        <T extends Tool> T register​(Class<T> tc,
                                    boolean enabled)
        Registers the tool of the given class if the tool instance of this class is not currently registered as tool. If a tool of this class is already registered, this method simply returns the registered instance. Otherwise a tool instance will be created, registered and returned.
        Type Parameters:
        T - type extending Tool
        Parameters:
        tc - The tool class
        enabled - Specifies whether the tool will initially be enabled or not
        Returns:
        the registered tool instance
      • deregister

        Tool deregister​(Class<? extends Tool> tc)

        Deregisters the tool of the given class if the tool instance of this class is currently registered as tool. The deregistered tool instance will be returned if a matching tool instance was found and deregistered. Otherwise null will be returned.

        Parameters:
        tc - the tool class
        Returns:
        the deregistered tool instance or null if available otherwise null. Be aware this tool instance is already deregistered when returned and can not be used as tool anymore.
      • activate

        void activate​(Class<? extends Tool> tc)

        Activates the tool of the given class.

        Parameters:
        tc - the tool class
        Throws:
        IllegalArgumentException - if no tool of the given class is currently managed by this ToolManager
      • handleEditEvent

        void handleEditEvent​(Class<?> context,
                             EditEvent e)
      • hasTool

        boolean hasTool​(Class<? extends Tool> cls)
        Returns whether this tool manager currently manages a tool of the given class.
        Parameters:
        cls - The class to check
        Returns:
        True, if a tool of the given class is managed, false else
      • getTool

        <T extends Tool> T getTool​(Class<T> cls)
        Returns the tool instance for the given tool class, or null if no such tool is registered.
        Type Parameters:
        T - A type extending Tool
        Parameters:
        cls - The class of the tool to return
        Returns:
        The tool if existing, null else
      • isActive

        boolean isActive​(Class<? extends Tool> tc)
        Return whether the tool of the given class is currently active.
        Parameters:
        tc - the tool class
        Returns:
        true if the tool is active
      • isExclusive

        boolean isExclusive()
        Return whether the exclusive tool mode is active, i.e. if the currently active tool is also the exclusive tool. In exclusive mode no tools except the exclusive one get a chance to render or handle events.
        Returns:
        true if exclusive mode is active
      • render

        void render​(RenderParameters parameters)
        Render the Tool UIs using the given RenderControls.

        This render method is usually called within the context and during the rendering of a single page. It will dispatch the render calls to all active tools.

        Parameters:
        parameters - the render parameters to use
      • setEnabled

        void setEnabled​(Class<? extends Tool> tc,
                        boolean enabled)
        Change the enabled state of the tool of the given class.
        Parameters:
        tc - the tool class
        enabled - true to enabled the tool, otherwise false
        Throws:
        IllegalArgumentException - if no tool of the given class is currently managed by this ToolManager
      • isEnabled

        boolean isEnabled​(Class<? extends Tool> tc)
        Checks whether the given Tool is enabled. This method will not fail if the Tool has not yet been registered. Instead, for non registered tools this method will return false.
        Parameters:
        tc - The class of the tool to check
        Returns:
        true if the Tool is enabled, or false if it is not or the Tool has not yet been registered.
      • setExclusive

        void setExclusive​(Class<? extends Tool> tc)
        Set the tool of the given class to be the exclusive tool.
        Parameters:
        tc - The class of the tool to make exclusive
        Throws:
        IllegalArgumentException - if no tool of the given class is currently managed by this ToolManager
      • setNonExclusive

        void setNonExclusive​(Class<? extends Tool> tc)
        Leave exclusive mode. Whatever tool is currently exclusive will loose its exclusive status. If there is currently no exclusive mode tool, this call has no effect.
        Parameters:
        tc - The class of the tool to make non-exclusive
      • addToolChangedHandler

        com.google.gwt.event.shared.HandlerRegistration addToolChangedHandler​(ToolChangedEvent.Handler handler)
        Adds a tool changed handler.
        Parameters:
        handler - the handler to add
        Returns:
        HandlerRegistration to remove the handler
      • getCompatibleTools

        <T> Collection<T> getCompatibleTools​(Class<T> clazz)
        Returns all registered Tools which are derived from the given class or which implement the given interface. Only tools in the state 'enabled' are considered.
        Type Parameters:
        T - type of class or interface in question
        Parameters:
        clazz - the class or interface in question
        Returns:
        a (possibly empty) collection of tools
      • getCompatibleTools

        <T> Collection<T> getCompatibleTools​(Class<T> clazz,
                                             boolean enabledOnly)
        Return all registered Tools which are derived from the given class or which implement the given interface.
        Type Parameters:
        T - type of class or interface in question
        Parameters:
        clazz - the class or interface in question
        enabledOnly - whether only enabled tools (true) or all registered tools shall be considered
        Returns:
        a (possibly empty) collection of tools
      • getRegisteredToolClasses

        Collection<Class<? extends Tool>> getRegisteredToolClasses()
        Allows access to all registered tool classes. This method will return active and inactive Tools. The returned Collection is read-only and does not follow any kind of sorting. (The order is random)
        Returns:
        a Collection of all registered Tool classes
      • getMenuContributors

        Collection<? extends MenuContributor> getMenuContributors()
        Return the current list of tools suitable as menu contributors.
        Returns:
        a read-only list of tools
      • getStatusFeedback

        String getStatusFeedback()
      • setStatusFeedback

        void setStatusFeedback​(String statusFeedback)
      • setViewComponent

        void setViewComponent​(ViewComponent viewComponent)
      • setCursor

        @Deprecated
        void setCursor​(com.google.gwt.dom.client.Style.Cursor cursor)
        Deprecated.
        Use setCursor(String) instead. To convert easily, just add .getCssName() to this method's cursor parameter
      • setCursor

        void setCursor​(String cursor)
        Sets the currently used cursor. Examples: setCursor("crosshair") or
        setCursor(UIStyler.get().cursorStyle().ZOOM_IN_CURSOR())
        Parameters:
        cursor - the css value of the cursor to be set
      • fireToolChangedEvent

        void fireToolChangedEvent​(ToolChangedEvent event)
        Fires a ToolChangedEvent to all listeners.
        Parameters:
        event - the ToolChangedEvent which should be fired