| /******************************************************************************* |
| * Copyright (c) 2000, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.forms.editor; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.swt.custom.BusyIndicator; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.widgets.*; |
| import org.eclipse.ui.*; |
| import org.eclipse.ui.forms.*; |
| import org.eclipse.ui.forms.widgets.ScrolledForm; |
| import org.eclipse.ui.part.EditorPart; |
| /** |
| * A base class that all pages that should be added to FormEditor must subclass. |
| * Form page has an instance of PageForm that extends managed form. Subclasses |
| * should override method 'createFormContent(ManagedForm)' to fill the form with |
| * content. Note that page itself can be loaded lazily (on first open). |
| * Consequently, the call to create the form content can come after the editor |
| * has been opened for a while (in fact, it is possible to open and close the |
| * editor and never create the form because no attempt has been made to show the |
| * page). |
| * |
| * @since 3.0 |
| */ |
| public class FormPage extends EditorPart implements IFormPage { |
| private FormEditor editor; |
| private PageForm mform; |
| private int index; |
| private String id; |
| |
| private static class PageForm extends ManagedForm { |
| public PageForm(FormPage page, ScrolledForm form) { |
| super(page.getEditor().getToolkit(), form); |
| setContainer(page); |
| } |
| |
| public FormPage getPage() { |
| return (FormPage)getContainer(); |
| } |
| public void dirtyStateChanged() { |
| getPage().getEditor().editorDirtyStateChanged(); |
| } |
| public void staleStateChanged() { |
| if (getPage().isActive()) |
| refresh(); |
| } |
| } |
| /** |
| * A constructor that creates the page and initializes it with the editor. |
| * |
| * @param editor |
| * the parent editor |
| * @param id |
| * the unique identifier |
| * @param title |
| * the page title |
| */ |
| public FormPage(FormEditor editor, String id, String title) { |
| this(id, title); |
| initialize(editor); |
| } |
| /** |
| * The constructor. The parent editor need to be passed in the |
| * <code>initialize</code> method if this constructor is used. |
| * |
| * @param id |
| * a unique page identifier |
| * @param title |
| * a user-friendly page title |
| */ |
| public FormPage(String id, String title) { |
| this.id = id; |
| setPartName(title); |
| } |
| /** |
| * Initializes the form page. |
| * |
| * @see IEditorPart#init |
| */ |
| public void init(IEditorSite site, IEditorInput input) { |
| setSite(site); |
| setInput(input); |
| } |
| /** |
| * Primes the form page with the parent editor instance. |
| * |
| * @param editor |
| * the parent editor |
| */ |
| public void initialize(FormEditor editor) { |
| this.editor = editor; |
| } |
| /** |
| * Returns the parent editor. |
| * |
| * @return parent editor instance |
| */ |
| public FormEditor getEditor() { |
| return editor; |
| } |
| /** |
| * Returns the managed form owned by this page. |
| * |
| * @return the managed form |
| */ |
| public IManagedForm getManagedForm() { |
| return mform; |
| } |
| /** |
| * Implements the required method by refreshing the form when set active. |
| * Subclasses must call super when overriding this method. |
| */ |
| public void setActive(boolean active) { |
| if (active) { |
| // We are switching to this page - refresh it |
| // if needed. |
| mform.refresh(); |
| } |
| } |
| /** |
| * Tests if the page is active by asking the parent editor if this page is |
| * the currently active page. |
| * |
| * @return <code>true</code> if the page is currently active, |
| * <code>false</code> otherwise. |
| */ |
| public boolean isActive() { |
| return this.equals(editor.getActivePageInstance()); |
| } |
| /** |
| * Creates the part control by creating the managed form using the parent |
| * editor's toolkit. Subclasses should override |
| * <code>createFormContent(IManagedForm)</code> to populate the form with |
| * content. |
| * |
| * @param parent |
| * the page parent composite |
| */ |
| public void createPartControl(Composite parent) { |
| ScrolledForm form = editor.getToolkit().createScrolledForm(parent); |
| mform = new PageForm(this, form); |
| BusyIndicator.showWhile(parent.getDisplay(), new Runnable() { |
| public void run() { |
| createFormContent(mform); |
| } |
| }); |
| } |
| /** |
| * Subclasses should override this method to create content in the form |
| * hosted in this page. |
| * |
| * @param managedForm |
| * the form hosted in this page. |
| */ |
| protected void createFormContent(IManagedForm managedForm) { |
| } |
| /** |
| * Returns the form page control. |
| * |
| * @return managed form's control |
| */ |
| public Control getPartControl() { |
| return mform != null ? mform.getForm() : null; |
| } |
| /** |
| * Disposes the managed form. |
| */ |
| public void dispose() { |
| if (mform != null) |
| mform.dispose(); |
| } |
| /** |
| * Returns the unique identifier that can be used to reference this page. |
| * |
| * @return the unique page identifier |
| */ |
| public String getId() { |
| return id; |
| } |
| /** |
| * Returns <code>null</code>- form page has no title image. Subclasses |
| * may override. |
| * |
| * @return <code>null</code> |
| */ |
| public Image getTitleImage() { |
| return null; |
| } |
| /** |
| * Sets the focus by delegating to the managed form. |
| */ |
| public void setFocus() { |
| if (mform != null) |
| mform.setFocus(); |
| } |
| /** |
| * @see org.eclipse.ui.ISaveablePart#doSave(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void doSave(IProgressMonitor monitor) { |
| if (mform != null) |
| mform.commit(true); |
| } |
| /** |
| * @see org.eclipse.ui.ISaveablePart#doSaveAs() |
| */ |
| public void doSaveAs() { |
| } |
| /** |
| * @see org.eclipse.ui.ISaveablePart#isSaveAsAllowed() |
| */ |
| public boolean isSaveAsAllowed() { |
| return false; |
| } |
| /** |
| * Implemented by testing if the managed form is dirty. |
| * |
| * @return <code>true</code> if the managed form is dirty, |
| * <code>false</code> otherwise. |
| * |
| * @see org.eclipse.ui.ISaveablePart#isDirty() |
| */ |
| public boolean isDirty() { |
| return mform != null ? mform.isDirty() : false; |
| } |
| /** |
| * Preserves the page index. |
| * |
| * @param index |
| * the assigned page index |
| */ |
| public void setIndex(int index) { |
| this.index = index; |
| } |
| /** |
| * Returns the saved page index. |
| * |
| * @return the page index |
| */ |
| public int getIndex() { |
| return index; |
| } |
| /** |
| * Form pages are not editors. |
| * |
| * @return <code>false</code> |
| */ |
| public boolean isEditor() { |
| return false; |
| } |
| /** |
| * Attempts to select and reveal the given object by passing the request to |
| * the managed form. |
| * |
| * @param object |
| * the object to select and reveal in the page if possible. |
| * @return <code>true</code> if the page has been successfully selected |
| * and revealed by one of the managed form parts, <code>false</code> |
| * otherwise. |
| */ |
| public boolean selectReveal(Object object) { |
| if (mform != null) |
| return mform.setInput(object); |
| return false; |
| } |
| /** |
| * By default, editor will be allowed to flip the page. |
| * @return <code>true</code> |
| */ |
| public boolean canLeaveThePage() { |
| return true; |
| } |
| } |