Class FormEditor

  • All Implemented Interfaces:
    IAdaptable, IExecutableExtension, IPageChangeProvider, IEditorPart, ISaveablePart, IWorkbenchPart, IWorkbenchPart2, IWorkbenchPart3, IWorkbenchPartOrientation
    Direct Known Subclasses:
    SharedHeaderFormEditor

    public abstract class FormEditor
    extends MultiPageEditorPart
    This class forms a base of multi-page form editors that typically use one or more pages with forms and one page for raw source of the editor input.

    Pages are added 'lazily' i.e. adding a page reserves a tab for it but does not cause the page control to be created. Page control is created when an attempt is made to select the page in question. This allows editors with several tabs and complex pages to open quickly.

    Subclasses should extend this class and implement addPages method. One of the two addPage methods should be called to contribute pages to the editor. One adds complete (standalone) editors as nested tabs. These editors will be created right away and will be hooked so that key bindings, selection service etc. is compatible with the one for the standalone case. The other method adds classes that implement IFormPage interface. These pages will be created lazily and they will share the common key binding and selection service. Since 3.1, FormEditor is a page change provider. It allows listeners to attach to it and get notified when pages are changed. This new API in JFace allows dynamic help to update on page changes.

    Since:
    3.0
    • Field Detail

      • pages

        protected Vector<Object> pages
        An array of pages currently in the editor. Page objects are not limited to those that implement IFormPage, hence the size of this array matches the number of pages as viewed by the user.

        Subclasses can access this field but should not modify it.

    • Constructor Detail

      • FormEditor

        public FormEditor()
        The constructor.
    • Method Detail

      • init

        public void init​(IEditorSite site,
                         IEditorInput input)
                  throws PartInitException
        Overrides super to plug in a different selection provider.
        Specified by:
        init in interface IEditorPart
        Overrides:
        init in class MultiPageEditorPart
        Parameters:
        site - The site for which this part is being created; must not be null.
        input - The input on which this editor should be created; must not be null.
        Throws:
        PartInitException - If the initialization of the part fails -- currently never.
      • createToolkit

        protected FormToolkit createToolkit​(Display display)
        Creates the form toolkit. The method can be implemented to substitute a subclass of the toolkit that should be used for this editor. A typical use of this method would be to create the form toolkit using one shared FormColors object to share resources across the multiple editor instances.
        Parameters:
        display - the display to use when creating the toolkit
        Returns:
        the newly created toolkit instance
      • addPages

        protected abstract void addPages()
        Subclass should implement this method to add pages to the editor using 'addPage(IFormPage)' method.
      • addPage

        public int addPage​(IFormPage page)
                    throws PartInitException
        Adds the form page to this editor. Form page will be loaded lazily. Its part control will not be created until it is activated for the first time.
        Parameters:
        page - the form page to add
        Throws:
        PartInitException
      • addPage

        public void addPage​(int index,
                            IFormPage page)
                     throws PartInitException
        Adds the form page to this editor at the specified index (0-based). Form page will be loaded lazily. Its part control will not be created until it is activated for the first time.
        Parameters:
        index - the position to add the page at (0-based)
        page - the form page to add
        Throws:
        PartInitException
        Since:
        3.1
      • isDirty

        public boolean isDirty()
        Tests whether the editor is dirty by checking all the pages that implement IFormPage. If none of them is dirty, the method delegates further processing to super.isDirty().
        Specified by:
        isDirty in interface ISaveablePart
        Overrides:
        isDirty in class MultiPageEditorPart
        Returns:
        true if any of the pages in the editor are dirty, false otherwise.
        Since:
        3.1
      • commitPages

        protected void commitPages​(boolean onSave)
        Commits all dirty pages in the editor. This method should be called as a first step of a 'save' operation.
        Parameters:
        onSave - true if commit is performed as part of the 'save' operation, false otherwise.
        Since:
        3.3
      • configurePage

        protected void configurePage​(int index,
                                     IFormPage page)
                              throws PartInitException
        Configures the form page.
        Parameters:
        index - the page index
        page - the page to configure
        Throws:
        PartInitException - if there are problems in configuring the page
      • editorDirtyStateChanged

        public void editorDirtyStateChanged()
        Called to indicate that the editor has been made dirty or the changes have been saved.
      • dispose

        public void dispose()
        Disposes the pages and the toolkit after disposing the editor itself. Subclasses must call 'super' when reimplementing the method.
        Specified by:
        dispose in interface IWorkbenchPart
        Overrides:
        dispose in class MultiPageEditorPart
      • getToolkit

        public FormToolkit getToolkit()
        Returns the toolkit owned by this editor.
        Returns:
        the toolkit object
      • getCurrentPage

        protected int getCurrentPage()
        Returns the current page index. The value is identical to the value of 'getActivePage()' except during the page switch, when this method still has the old active page index.

        Another important difference is during the editor closing. When the tab folder is disposed, 'getActivePage()' will return -1, while this method will still return the last active page.

        Returns:
        the currently selected page or -1 if no page is currently selected
        See Also:
        MultiPageEditorPart.getActivePage()
      • pageChange

        protected void pageChange​(int newPageIndex)
        Description copied from class: MultiPageEditorPart
        Notifies this multi-page editor that the page with the given id has been activated. This method is called when the user selects a different tab.

        The MultiPageEditorPart implementation of this method sets focus to the new page, and notifies the action bar contributor (if there is one). This checks whether the action bar contributor is an instance of MultiPageEditorActionBarContributor, and, if so, calls setActivePage with the active nested editor. This also fires a selection change event if required.

        Subclasses may extend this method.

        Overrides:
        pageChange in class MultiPageEditorPart
        Parameters:
        newPageIndex - the index of the activated page
        See Also:
        MultiPageEditorPart.pageChange(int)
      • setActivePage

        public IFormPage setActivePage​(String pageId)
        Sets the active page using the unique page identifier.
        Parameters:
        pageId - the id of the page to switch to
        Returns:
        page that was set active or null if not found.
      • findPage

        public IFormPage findPage​(String pageId)
        Finds the page instance that has the provided id.
        Parameters:
        pageId - the id of the page to find
        Returns:
        page with the matching id or null if not found.
      • setActivePage

        public IFormPage setActivePage​(String pageId,
                                       Object pageInput)
        Sets the active page using the unique page identifier and sets its input to the provided object.
        Parameters:
        pageId - the id of the page to switch to
        pageInput - the page input
        Returns:
        page that was set active or null if not found.
      • selectReveal

        public IFormPage selectReveal​(Object pageInput)
        Iterates through the pages calling similar method until a page is found that contains the desired page input.
        Parameters:
        pageInput - the object to select and reveal
        Returns:
        the page that accepted the request or null if no page has the desired object.
        See Also:
        setActivePage(String, Object)
      • getActivePageInstance

        public IFormPage getActivePageInstance()
        Returns active page instance if the currently selected page index is not -1 and active page is a IFormPage, or null otherwise.
        Returns:
        active page instance if selected, or null if no page is currently active.
        See Also:
        MultiPageEditorPart.getSelectedPage()
      • updateActionBarContributor

        protected void updateActionBarContributor​(int pageIndex)
        Notifies action bar contributor about page change.
        Parameters:
        pageIndex - the index of the new page
      • close

        public void close​(boolean save)
        Closes the editor programmatically.
        Parameters:
        save - if true, the content should be saved before closing.