public static final String TAG_EDITOR_STATE = "editorState"; //$NON-NLS-1$

import org.eclipse.ui.IEditorPersistable;

	private IMemento editorState;

        editorState = editorMemento.getChild(IWorkbenchConstants.TAG_EDITOR_STATE);

        editorState = null;

        editorState = null;

            // if there is saved state that's appropriate, pass it on

            if (part instanceof IEditorPersistable && editorState != null) {

				((IEditorPersistable) part).restoreState(editorState);

			}

import org.eclipse.ui.IEditorPersistable;

				// any editors that want to persist state

				if (editor instanceof IEditorPersistable) {

					IMemento editorState = editorMem

							.createChild(IWorkbenchConstants.TAG_EDITOR_STATE);

					((IEditorPersistable) editor).saveState(editorState);

				}

/*******************************************************************************

 * Copyright (c) 2006 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;

/**

 * An editor can implement this interface and participate in the workbench

 * session save/restore cycle using <code>IMemento</code>, similar to how

 * <code>IViewPart</code> currently works.

 * <p>

 * Refer to IWorkbenchPart for the part lifecycle.

 * </p>

 * <p>

 * If a memento is available, restoreState(*) will be inserted into the editor

 * startup.

 * <ol>

 * <li><code>editor.init(site, input)</code></li>

 * <li><code>editor.restoreState(memento)</code></li>

 * <li><code>editor.createPartControl(parent)</code></li>

 * <li>...</li>

 * </ol>

 * </p>

 * <p>

 * On workbench shutdown, the editor state will be persisted when the editor

 * references are saved.

 * </p>

 * 

 * @since 3.3

 */

public interface IEditorPersistable extends IPersistable {

	/**

	 * Called with a memento for this editor. The editor can parse the data or

	 * save the memento. This method may not be called.

	 * 

	 * @param memento

	 *            the saved state for this editor. May be <code>null</code>.

	 */

	public void restoreState(IMemento memento);

}

            name="Mock Editor Save"

            extensions="mocksave"

            icon="icons\mockeditorpart1.gif"

            class="org.eclipse.ui.tests.api.MockEditorWithState"

            id="org.eclipse.ui.tests.api.MockEditorStatePart">

      </editor>

      <editor

	/**

	 * Tests that the editor is closed without saving if isSaveOnCloseNeeded()

	 * returns false.

	 * 

	 * @see ISaveablePart#isSaveOnCloseNeeded()

	 */

	public void testOpenAndCloseSaveNotNeeded() throws Throwable {

		// Open a part.

		MockEditorPart part = (MockEditorPart) openPart(fPage);

		part.setDirty(true);

		part.setSaveNeeded(false);

		closePart(fPage, part);

		CallHistory history = part.getCallHistory();

		assertTrue(history.verifyOrder(new String[] { "setInitializationData",

				"init", "createPartControl", "setFocus", "isSaveOnCloseNeeded",

				"widgetDisposed", "dispose" }));

		assertFalse(history.contains("doSave"));

	}

	public void testOpenAndCloseWithNoMemento() throws Throwable {

		IProject proj = FileUtil.createProject("IEditorPartTest");

		IFile file = FileUtil.createFile("IEditorPartTest.txt", proj);

		MockEditorWithState editor = (MockEditorWithState) fPage.openEditor(

				new FileEditorInput(file), MockEditorWithState.ID);

		closePart(fPage, editor);

		CallHistory history = editor.getCallHistory();

		assertFalse(history.contains("saveState"));

		assertFalse(history.contains("restoreState"));

	}

}

		addTest(new WorkbenchSessionTest("editorSessionTests",

				EditorWithStateTest.class));

/*******************************************************************************

 * Copyright (c) 2000, 2006 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.tests.api;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IActionBars;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorPersistable;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.PartInitException;

public class MockEditorWithState extends MockWorkbenchPart implements

		IEditorPart, IEditorPersistable {

	public static final String ID = "org.eclipse.ui.tests.api.MockEditorStatePart";

	public static final String NAME = "Mock Editor State 1";

	private IEditorInput input;

	private boolean dirty = false;

	private boolean saveNeeded = true;

	private boolean saveAsAllowed = false;

	public MockEditorWithState() {

		super();

	}

	public void createPartControl(Composite parent) {

		super.createPartControl(parent);

		final Button dirtyToggle = new Button(parent, SWT.CHECK);

		dirtyToggle.setText("Dirty");

		dirtyToggle.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				setDirty(dirtyToggle.getSelection());

			}

		});

		dirtyToggle.setSelection(isDirty());

		final Button saveNeededToggle = new Button(parent, SWT.CHECK);

		saveNeededToggle.setText("Save on close");

		saveNeededToggle.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				setSaveNeeded(saveNeededToggle.getSelection());

			}

		});

		saveNeededToggle.setSelection(saveNeeded);

		final Button saveAsToggle = new Button(parent, SWT.CHECK);

		saveAsToggle.setText("Save as allowed");

		saveAsToggle.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				setSaveAsAllowed(saveAsToggle.getSelection());

			}

		});

		saveAsToggle.setSelection(saveAsAllowed);

	}

	/**

	 * @see IEditorPart#doSave(IProgressMonitor)

	 */

	public void doSave(IProgressMonitor monitor) {

		setDirty(false);

		callTrace.add("doSave");

	}

	/**

	 * @see IEditorPart#doSaveAs()

	 */

	public void doSaveAs() {

	}

	/**

	 * @see IEditorPart#getEditorInput()

	 */

	public IEditorInput getEditorInput() {

		return input;

	}

	/**

	 * @see IEditorPart#getEditorSite()

	 */

	public IEditorSite getEditorSite() {

		return (IEditorSite) getSite();

	}

	/**

	 * @see IEditorPart#init(IEditorSite, IEditorInput)

	 */

	public void init(IEditorSite site, IEditorInput input)

			throws PartInitException {

		this.input = input;

		setSite(site);

		callTrace.add("init");

		setSiteInitialized();

	}

	/**

	 * @see IEditorPart#isDirty()

	 */

	public boolean isDirty() {

		callTrace.add("isDirty");

		return dirty;

	}

	public void setDirty(boolean value) {

		dirty = value;

		firePropertyChange(PROP_DIRTY);

	}

	/**

	 * @see IEditorPart#isSaveAsAllowed()

	 */

	public boolean isSaveAsAllowed() {

		callTrace.add("isSaveAsAllowed");

		return saveAsAllowed;

	}

	/**

	 * @see IEditorPart#isSaveOnCloseNeeded()

	 */

	public boolean isSaveOnCloseNeeded() {

		callTrace.add("isSaveOnCloseNeeded");

		return saveNeeded;

	}

	public void setSaveAsAllowed(boolean isSaveAsAllowed) {

		this.saveAsAllowed = isSaveAsAllowed;

	}

	public void setSaveNeeded(boolean value) {

		saveNeeded = value;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.ui.tests.api.MockWorkbenchPart#getActionBars()

	 */

	protected IActionBars getActionBars() {

		return getEditorSite().getActionBars();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.ui.IEditorPersistable#restoreState(org.eclipse.ui.IMemento)

	 */

	public void restoreState(IMemento memento) {

		callTrace.add("restoreState");

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.ui.IPersistable#saveState(org.eclipse.ui.IMemento)

	 */

	public void saveState(IMemento memento) {

		callTrace.add("saveState");

	}

}

/*******************************************************************************

 * Copyright (c) 2004, 2006 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.tests.session;

import junit.framework.TestCase;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.ui.IWorkbench;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.part.FileEditorInput;

import org.eclipse.ui.tests.api.MockEditorWithState;

import org.eclipse.ui.tests.harness.util.FileUtil;

/**

 * A test to verify the persistence of handler state between sessions.

 * 

 * @since 3.2

 */

public class EditorWithStateTest extends TestCase {

	/**

	 * Constructs a new instance of <code>EditorWithStateTest</code>.

	 * 

	 * @param testName

	 *            The name of the test; may be <code>null</code>.

	 */

	public EditorWithStateTest(final String testName) {

		super(testName);

	}

	public void testInitialEditorOpen() throws Exception {

		final IWorkbench workbench = PlatformUI.getWorkbench();

		final IWorkbenchPage page = workbench.getActiveWorkbenchWindow()

				.getActivePage();

		IProject proj = FileUtil.createProject("EditorSessionTest");

		IFile file = FileUtil.createFile("state.txt", proj);

		MockEditorWithState editor = (MockEditorWithState) page.openEditor(

				new FileEditorInput(file), MockEditorWithState.ID);

		assertFalse(editor.getCallHistory().contains("saveState"));

		assertFalse(editor.getCallHistory().contains("restoreState"));

	}

	public void testSecondEditorOpen() throws Exception {

		final IWorkbench workbench = PlatformUI.getWorkbench();

		final IWorkbenchPage page = workbench.getActiveWorkbenchWindow()

				.getActivePage();

		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(

				"EditorSessionTest");

		IFile file = project.getFile("state.txt");

		MockEditorWithState editor = (MockEditorWithState) page

				.findEditor(new FileEditorInput(file));

		assertNotNull(editor);

		assertFalse(editor.getCallHistory().contains("saveState"));

		assertTrue(editor.getCallHistory().contains("restoreState"));

	}

}