Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.
E4/EAS/Saveable Life Cycle
When a user modifies something, a component may choose to notify the user of this in some way. This state transition from "unmodified" to "modified" is known as the "dirty state". When something is dirty, it means that the user has interacted with the object in some way. It may or may not actually be different from the original object but is an indicator to the user that something may be different.
One example of where an editor may be dirty but no actually have its contents be different from the file on disk is where a user has inserted a character and then removed it from the document. Both the insertion and deletion operation are modification operations even if the contents are identical to what's on the disk. However, if the user were to undo the insertion operation instead of using a deletion operation to remove the change, then the dirty state should be cleared.
Contents
Eclipse 3.x API
In Eclipse 3.x, the visual cue to the user that a workbench part is dirty is by appending the asterisk character ('*') in front of the part's title. So if the original file was called 'Main.java' and it was edited by the user in the text editor, the title in the tab would switch from 'Main.java' to '*Main.java'. Workbench parts that wish to expose this functionality do so by implementing the org.eclipse.ui.ISaveablePart interface.
Saveable declaration
public class ModelTransformationView extends ViewPart implements ISaveablePart { private boolean fDirty = false; /** * Alters the dirty state of this part and notifies the workbench * of the change. */ private void setDirty(boolean dirty) { if (fDirty != dirty) { fDirty = dirty; // send a notification about our dirty state changing firePropertyChange(IWorkbenchPartConstants.PROP_DIRTY); } } public boolean isDirty() { return fDirty; } /* Other code not included... */ }
Dirty state modification
fStateCheckbox.addListener(SWT.Selection, new Listener() { public void handleEvent(Event e) { // modify the model based on what the user selected // in the UI fModel.setState(fStateCheckbox.getSelection()); // send out a dirty notification setDirty(true); } });
Saving
public class ModelTransformationView extends ViewPart implements ISaveablePart { public void doSave(IProgressMonitor monitor) { /* Perform the save operation */ } /* Other code not included... */ }
e4 (Java)
Saveable declaration
In your XMI file, you should define your part as a SaveablePart instead of a regular Part. You can also use Editor if you wish.
A SaveablePart is both a regular Part and a Dirtyable so it is essentially a part with a dirty state that can be toggled on and off.
An Editor is both a SaveablePart and an Input so it has a dirty state for toggling but it also has an input. This input would commonly be a file but is completely arbitrary.
<children xsi:type="application:SaveablePart" id="MySaveablePart" URI="platform:/plugin/org.eclipse.e4.examples/org.eclipse.e4.examples.MySaveablePart" name="MySaveablePart" iconURI="platform:/plugin/org.eclipse.e4.demo.contacts/icons/silk/folder_user.png"/>
You can then retrieve a Dirtyable instance from your part implementation through injection.
public class MySaveablePart { @Inject private MDirtyable dirtyable; }
public class MySaveablePart { private MDirtyable dirtyable; public MySaveablePart(MDirtyable dirtyable) { this.dirtyable = dirtyable; } }
Dirty state modification
public void setDirty(boolean dirty) { dirtyable.setDirty(dirty); }