Java tutorial
/******************************************************************************* * Copyright (c) 2012, 2013 Dirk Fauth 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: * Dirk Fauth - initial API and implementation *******************************************************************************/ package org.eclipse.nebula.widgets.nattable.persistence.gui; import java.util.ArrayList; import java.util.List; import java.util.Properties; import org.eclipse.jface.dialogs.Dialog; import org.eclipse.jface.dialogs.IDialogConstants; import org.eclipse.jface.fieldassist.ControlDecoration; import org.eclipse.jface.fieldassist.FieldDecorationRegistry; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.jface.viewers.ArrayContentProvider; import org.eclipse.jface.viewers.DoubleClickEvent; import org.eclipse.jface.viewers.IDoubleClickListener; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ISelectionChangedListener; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.StyledCellLabelProvider; import org.eclipse.jface.viewers.StyledString; import org.eclipse.jface.viewers.StyledString.Styler; import org.eclipse.jface.viewers.TableViewer; import org.eclipse.jface.viewers.ViewerCell; import org.eclipse.jface.viewers.ViewerComparator; import org.eclipse.nebula.widgets.nattable.Messages; import org.eclipse.nebula.widgets.nattable.NatTable; import org.eclipse.nebula.widgets.nattable.columnChooser.command.DisplayColumnChooserCommandHandler; import org.eclipse.nebula.widgets.nattable.persistence.PersistenceHelper; import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommand; import org.eclipse.nebula.widgets.nattable.persistence.command.DisplayPersistenceDialogCommandHandler; import org.eclipse.nebula.widgets.nattable.persistence.command.IStateChangedListener; import org.eclipse.nebula.widgets.nattable.persistence.command.StateChangeEvent; import org.eclipse.nebula.widgets.nattable.persistence.command.StateChangeEvent.StateChangeType; import org.eclipse.nebula.widgets.nattable.util.GUIHelper; import org.eclipse.swt.SWT; import org.eclipse.swt.events.KeyAdapter; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.ModifyEvent; import org.eclipse.swt.events.ModifyListener; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.TextStyle; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; /** * Dialog that allows to save and load NatTable state. * It will operate on the the specified NatTable and Properties instances. * If the Properties need to be persisted e.g. in the file system, the * developer has to take care of that himself. * * <p>It is possible to listen for state change events on the view configurations. * Rather than adding listeners to this dialog yourself, you should register the * listeners to the {@link DisplayColumnChooserCommandHandler}, as it will handle * propagating the listeners to newly created instances of this dialog. * * @author Dirk Fauth * * @see DisplayPersistenceDialogCommand * @see DisplayPersistenceDialogCommandHandler */ public class PersistenceDialog extends Dialog { /** * Key under which the name of the active view configuration is stored within the properties. * Used to indicate which view configuration is currently active and to be able to restore * a view based on the last active one, when persisting the states to a file or database. */ public static final String ACTIVE_VIEW_CONFIGURATION_KEY = "PersistenceDialog.activeViewConfiguration"; //$NON-NLS-1$ /** * Constant ID for the save button of this dialog. */ public static final int SAVE_ID = 2; /** * Constant ID for the load button of this dialog. */ public static final int LOAD_ID = 3; /** * Constant ID for the delete button of this dialog. */ public static final int DELETE_ID = 4; /** * The NatTable instance to apply the save/load operations. */ private NatTable natTable; /** * The Properties instance that should be used for saving and loading. */ private Properties properties; /** * Viewer containing the state configurations. */ private TableViewer viewer; /** * The decoration for the configNameText field. Needed for showing an error * when trying to invoke save with an empty name. */ private ControlDecoration configNameDeco; /** * Text input field for specifying the name of a configuration. * If there is no input in this field when saving a state configuration * the default state configuration will be used. */ private Text configNameText; /** * List of {@link IStateChangedListener}s that will be notified if states are changed * using this dialog. */ private List<IStateChangedListener> stateChangeListeners = new ArrayList<IStateChangedListener>(); /** * Create a new dialog for handling NatTable state. * * @param parentShell the parent shell, or <code>null</code> to create a top-level shell * @param natTable The NatTable instance to apply the save/load operations. * @param properties The Properties instance that should be used for saving and loading. */ public PersistenceDialog(Shell parentShell, NatTable natTable, Properties properties) { super(parentShell); setShellStyle(SWT.RESIZE | SWT.APPLICATION_MODAL | SWT.DIALOG_TRIM); if (natTable == null) { throw new IllegalArgumentException("natTable can not be null!"); //$NON-NLS-1$ } if (properties == null) { throw new IllegalArgumentException("properties can not be null!"); //$NON-NLS-1$ } this.natTable = natTable; this.properties = properties; } /* (non-Javadoc) * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite) */ @Override protected Control createDialogArea(Composite parent) { Composite control = (Composite) super.createDialogArea(parent); Label viewerLabel = new Label(control, SWT.NONE); viewerLabel.setText(Messages.getString("PersistenceDialog.viewerLabel")); //$NON-NLS-1$ GridDataFactory.fillDefaults().grab(true, false).applyTo(viewerLabel); this.viewer = new TableViewer(control); this.viewer.setContentProvider(new ArrayContentProvider()); this.viewer.setLabelProvider(new ViewConfigurationNameLabelProvider()); //sort in alphabetical order this.viewer.setComparator(new ViewerComparator()); GridDataFactory.fillDefaults().grab(true, true).applyTo(this.viewer.getControl()); //layout textbox Composite nameContainer = new Composite(control, SWT.NONE); GridLayout layout = new GridLayout(2, false); layout.marginWidth = 0; nameContainer.setLayout(layout); GridDataFactory.fillDefaults().grab(true, false).applyTo(nameContainer); Label label = new Label(nameContainer, SWT.NONE); label.setText(Messages.getString("PersistenceDialog.nameLabel")); //$NON-NLS-1$ this.configNameText = new Text(nameContainer, SWT.BORDER); GridDataFactory.fillDefaults().grab(true, false).applyTo(this.configNameText); this.configNameText.addKeyListener(new KeyAdapter() { @Override public void keyPressed(KeyEvent event) { if ((event.keyCode == SWT.CR && event.stateMask == 0) || (event.keyCode == SWT.KEYPAD_CR && event.stateMask == 0)) { buttonPressed(SAVE_ID); } } }); this.configNameText.addModifyListener(new ModifyListener() { public void modifyText(ModifyEvent e) { if (configNameText.getText().length() != 0) { configNameDeco.hide(); } } }); this.configNameDeco = new ControlDecoration(this.configNameText, SWT.RIGHT); Image image = FieldDecorationRegistry.getDefault().getFieldDecoration(FieldDecorationRegistry.DEC_ERROR) .getImage(); this.configNameDeco.setDescriptionText(Messages.getString("PersistenceDialog.nameErrorText")); //$NON-NLS-1$ this.configNameDeco.setImage(image); this.configNameDeco.hide(); //add click listener on viewer this.viewer.addSelectionChangedListener(new ISelectionChangedListener() { public void selectionChanged(SelectionChangedEvent event) { ISelection selection = event.getSelection(); if (selection != null && selection instanceof IStructuredSelection) { String configName = ((IStructuredSelection) selection).getFirstElement().toString(); configNameText.setText(configName); } } }); //add double click listener this.viewer.addDoubleClickListener(new IDoubleClickListener() { public void doubleClick(DoubleClickEvent event) { buttonPressed(LOAD_ID); } }); this.viewer.add(PersistenceHelper.getAvailableStates(this.properties).toArray()); return control; } /* (non-Javadoc) * @see org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite) */ @Override protected void createButtonsForButtonBar(Composite parent) { createButton(parent, DELETE_ID, Messages.getString("PersistenceDialog.buttonDelete"), false); //$NON-NLS-1$ createButton(parent, SAVE_ID, Messages.getString("PersistenceDialog.buttonSave"), false); //$NON-NLS-1$ createButton(parent, LOAD_ID, Messages.getString("PersistenceDialog.buttonLoad"), false); //$NON-NLS-1$ createButton(parent, IDialogConstants.OK_ID, Messages.getString("PersistenceDialog.buttonDone"), false); //$NON-NLS-1$ } /* (non-Javadoc) * @see org.eclipse.jface.dialogs.Dialog#buttonPressed(int) */ @Override protected void buttonPressed(int buttonId) { if (buttonId == SAVE_ID) { String configName = this.configNameText.getText(); if (configName == null || configName.length() == 0) { //it is not possible to store an empty configuration with this dialog //this is because the configuration with an empty name is the default //configuration this.configNameDeco.show(); return; } else { this.configNameDeco.hide(); } this.natTable.saveState(configName, this.properties); String oldActiveName = getActiveViewConfigurationName(); setActiveViewConfigurationName(configName); this.viewer.refresh(oldActiveName, true); this.configNameText.setText(""); //$NON-NLS-1$ for (int i = 0; i < this.viewer.getTable().getItemCount(); i++) { String element = this.viewer.getElementAt(i).toString(); if (configName.equals(element)) { //fire event for a changed view configuration fireStateChange(new StateChangeEvent(configName, StateChangeType.CHANGE)); return; } } this.viewer.add(configName); //fire event for a newly created view configuration fireStateChange(new StateChangeEvent(configName, StateChangeType.CREATE)); } else if (buttonId == DELETE_ID) { ISelection selection = this.viewer.getSelection(); if (selection != null && selection instanceof IStructuredSelection) { String configName = ((IStructuredSelection) selection).getFirstElement().toString(); PersistenceHelper.deleteState(configName, this.properties); //remove the state name out of the viewer this.viewer.getTable().deselectAll(); this.viewer.remove(configName); this.configNameText.setText(""); //$NON-NLS-1$ //fire event for a deleted view configuration fireStateChange(new StateChangeEvent(configName, StateChangeType.DELETE)); } } else if (buttonId == LOAD_ID) { ISelection selection = this.viewer.getSelection(); if (selection != null && selection instanceof IStructuredSelection) { String configName = ((IStructuredSelection) selection).getFirstElement().toString(); this.natTable.loadState(configName, this.properties); setActiveViewConfigurationName(configName); } super.okPressed(); } else { super.buttonPressed(buttonId); } } /* (non-Javadoc) * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell) */ @Override protected void configureShell(Shell newShell) { super.configureShell(newShell); newShell.setText(Messages.getString("PersistenceDialog.title")); //$NON-NLS-1$ newShell.setImage(GUIHelper.getImage("table_icon")); //$NON-NLS-1$ } /* (non-Javadoc) * @see org.eclipse.jface.dialogs.Dialog#getInitialSize() */ @Override protected Point getInitialSize() { return new Point(500, 300); }; /** * @return The Properties instance that is used for saving and loading. */ public Properties getProperties() { return properties; } /** * @param properties The Properties instance that should be used for saving and loading. */ public void setProperties(Properties properties) { this.properties = properties; } /** * @return The name of the current active view configuration */ public String getActiveViewConfigurationName() { return this.properties.getProperty(ACTIVE_VIEW_CONFIGURATION_KEY); } /** * Sets the name of the current active view configuration. * Note that this method does not set the active view configuration programmatically. * It is just used to support highlighting the current active view configuration * in the viewer of this dialog. * @param name The name of the current active view configuration */ public void setActiveViewConfigurationName(String name) { this.properties.setProperty(ACTIVE_VIEW_CONFIGURATION_KEY, name); } /** * Add the given {@link IStateChangedListener} to the local list of listeners. * @param listener The listener to add. */ public void addStateChangeListener(IStateChangedListener listener) { this.stateChangeListeners.add(listener); } /** * Adds the given {@link IStateChangedListener}s to the local list of listeners. * @param listeners The listeners to add. */ public void addAllStateChangeListener(List<IStateChangedListener> listeners) { this.stateChangeListeners.addAll(listeners); } /** * Removes the given {@link IStateChangedListener} from the local list of listeners. * @param listener The listener to remove. */ public void removeStateChangeListener(IStateChangedListener listener) { this.stateChangeListeners.remove(listener); } /** * Removes the given {@link IStateChangedListener}s from the local list of listeners. * @param listeners The listeners to remove. */ public void removeAllStateChangeListener(List<IStateChangedListener> listeners) { this.stateChangeListeners.removeAll(listeners); } /** * Inform all registered listeners about the state change. * @param event The {@link StateChangeEvent} object. */ public void fireStateChange(StateChangeEvent event) { for (IStateChangedListener listener : this.stateChangeListeners) { listener.handleStateChange(event); } } /** * Special StyledCellLabelProvider that will render the default view configuration * italic, so a user will know that there is something special about it. * Will also add a leading '*' to the current active view configuration. */ class ViewConfigurationNameLabelProvider extends StyledCellLabelProvider { private Font italicFont; private Styler italicStyler; ViewConfigurationNameLabelProvider() { italicFont = GUIHelper.getFont(new FontData[] { new FontData("Arial", 8, SWT.ITALIC) }); //$NON-NLS-1$ italicStyler = new Styler() { @Override public void applyStyles(TextStyle textStyle) { textStyle.font = italicFont; } }; } @Override public void update(ViewerCell cell) { Object element = cell.getElement(); String result = element == null ? "" : element.toString();//$NON-NLS-1$ String prefix = ""; //$NON-NLS-1$ if (result.equals(getActiveViewConfigurationName())) { prefix = "* "; //$NON-NLS-1$ } Styler styler = null; if (result.length() == 0) { result = Messages.getString("PersistenceDialog.defaultStateConfigName"); //$NON-NLS-1$ styler = italicStyler; } StyledString styledString = new StyledString(prefix + result, styler); cell.setText(styledString.toString()); cell.setStyleRanges(styledString.getStyleRanges()); super.update(cell); } } }