spellcorrectionview.java

Eclipse高级编程3源码(书本源码)

/*******************************************************************************
 * Copyright (c) 2003 Berthold Daum. All rights reserved. This program and the
 * accompanying materials are made available under the terms of the Common
 * Public License v1.0 which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors: Berthold Daum
 ******************************************************************************/
package com.bdaum.SpellChecker.views;

import java.util.List;

import org.eclipse.jface.action.*;
import org.eclipse.jface.viewers.*;
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.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.ui.part.ViewPart;

import com.bdaum.SpellChecker.SpellCheckManager;
import com.bdaum.SpellChecker.SpellCheckerImages;
import com.bdaum.SpellChecker.SpellCheckerPlugin;
import com.bdaum.SpellChecker.actions.CheckSpellingActionDelegate;
import com.bdaum.SpellChecker.actions.CorrectionViewAction;
import com.swabunga.spell.engine.Word;
import com.swabunga.spell.event.SpellCheckEvent;
import com.bdaum.SpellChecker.Messages;

public class SpellCorrectionView extends ViewPart {

	// Text constant for cases where we have no correction proposals
	private static final String[] NOPROPOSALS = new String[] { Messages
			.getString("SpellCorrectionView.No_suggestions") };

	/* Widgets */
	// The current Display instance
	private Display display;

	// The Text widget for displaying the bad word
	private Text badWord;

	// The TableViewer of this view
	private TableViewer viewer;

	/* View actions */
	// Toolbar and menu actions
	private IAction ignoreAction;

	private IAction ignoreAllAction;

	private IAction cancelAction;

	private IAction replaceAction;

	private IAction replaceAllAction;

	private IAction addToDictionaryAction;

	// The double click action
	private Action doubleClickAction;

	/* The manager */
	private SpellCheckManager spellCheckManager;

	/* The current spelling error event */
	private SpellCheckEvent currentEvent;

	/* Indicator if replacements are allowed */
	private boolean documentIsEditable;

	/**
	 * The ViewContentProvider creates the table content from the spelling error
	 * event.
	 */
	class ViewContentProvider implements IStructuredContentProvider {

		// Current spelling error event
		private Object spEvent;

		/**
		 * This method is called by the TableViewer after setInput() was called.
		 */
		public void inputChanged(Viewer v, Object oldInput, Object newInput) {
			spEvent = newInput;
		}

		/**
		 * This method is called when the table is refreshed
		 */
		public Object[] getElements(Object parent) {
			// Fetch correction proposals from the spelling error event
			if (spEvent instanceof SpellCheckEvent) {
				List suggestions = ((SpellCheckEvent) spEvent).getSuggestions();
				int s = suggestions.size();
				// Check if we have proposals
				if (s > 0) {
					// Return correction proposals as an array to the
					// TableViewer
					Word[] sugArray = new Word[s];
					suggestions.toArray(sugArray);
					return sugArray;
				}
			}
			return NOPROPOSALS;
		}

		public void dispose() {
		}
	}

	/**
	 * The ViewLabelProvider creates the individual table entries
	 */
	class ViewLabelProvider extends LabelProvider implements
			ITableLabelProvider {

		/*
		 * Process text for table entry
		 */
		public String getColumnText(Object obj, int index) {
			return getText(obj);
		}

		public Image getColumnImage(Object obj, int index) {
			return null;
		}

		public Image getImage(Object obj) {
			return null;
		}
	}

	public void createPartControl(Composite parent) {
		// Fetch Display instance for later usage
		display = parent.getDisplay();
		// Set GridLayout
		parent.setLayout(new GridLayout());
		// Create Text widget for display of bad word
		badWord = new Text(parent, SWT.BORDER);
		badWord.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		// Disable/Enable actions when content of text field changes
		badWord.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				updateActionEnablement();
			}
		});
		// Create table viewer
		viewer = new TableViewer(parent, SWT.H_SCROLL | SWT.V_SCROLL
				| SWT.BORDER);
		viewer.getControl().setLayoutData(new GridData(GridData.FILL_BOTH));
		// Set ContentProvider and LabelProvider
		viewer.setContentProvider(new ViewContentProvider());
		viewer.setLabelProvider(new ViewLabelProvider());
		// Listener for selection of table elements
		// Selected elements are copied to text field badWord.
		viewer.addSelectionChangedListener(new ISelectionChangedListener() {
			public void selectionChanged(SelectionChangedEvent event) {
				ISelection sel = event.getSelection();
				if (sel instanceof IStructuredSelection) {
					Object obj = ((IStructuredSelection) sel).getFirstElement();
					// Check for Word type to exclude NOPROPOSALS
					// from selection
					if (obj instanceof Word)
						badWord.setText(obj.toString());
				}
			}
		});
		// Add KeyListener to support keyboard shortcuts
		viewer.getControl().addKeyListener(new KeyAdapter() {
			public void keyPressed(KeyEvent e) {
				if (e.character == '+')
					addToDictionaryAction.run();
				else
					switch (e.keyCode) {
					case 13:
						if ((e.stateMask & SWT.CTRL) != 0) {
							if ((e.stateMask & SWT.SHIFT) != 0)
								replaceAllAction.run();
							else
								replaceAction.run();
						} else {
							if ((e.stateMask & SWT.SHIFT) != 0)
								ignoreAllAction.run();
							else
								ignoreAction.run();
						}
						break;
					case SWT.ESC:
						cancelAction.run();
						break;
					}
			}
		});

		// Create actions
		makeActions();
		// Add the context menu
		hookContextMenu();
		// Add the double click action
		hookDoubleClickAction();
		// Create the toolbar
		contributeToActionBars();
		// Initialize the actions
		updateActionEnablement();
		// Create help context
		WorkbenchHelp.setHelp(parent,
				"com.bdaum.SpellChecker.correctionView_context");
	}

	/**
	 * Set focus to TableViewer
	 */
	public void setFocus() {
		viewer.getControl().setFocus();
	}

	// Add double click action
	private void hookDoubleClickAction() {
		viewer.addDoubleClickListener(new IDoubleClickListener() {
			public void doubleClick(DoubleClickEvent event) {
				doubleClickAction.run();
			}
		});
	}

	// Add context menu
	private void hookContextMenu() {
		// Create new menu manager
		MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
		// Remove all menu items before building the menu
		menuMgr.setRemoveAllWhenShown(true);
		// Event processing for context menu
		menuMgr.addMenuListener(new IMenuListener() {
			public void menuAboutToShow(IMenuManager manager) {
				SpellCorrectionView.this.fillContribution(manager);
			}
		});
		// Create menu
		Menu menu = menuMgr.createContextMenu(viewer.getControl());
		viewer.getControl().setMenu(menu);
		// Register context menu with workbench site
		getSite().registerContextMenu(menuMgr, viewer);
	}

	private void contributeToActionBars() {
		// Fetch action bar from workbench site
		IActionBars bars = getViewSite().getActionBars();
		// Create the drop-down menu
		fillContribution(bars.getMenuManager());
		// Create the toolbar
		fillContribution(bars.getToolBarManager());
	}

	// Fill menus or toolbar with actions
	private void fillContribution(IContributionManager manager) {
		manager.add(replaceAction);
		manager.add(replaceAllAction);
		manager.add(new Separator());
		manager.add(addToDictionaryAction);
		manager.add(new Separator());
		manager.add(ignoreAction);
		manager.add(ignoreAllAction);
		manager.add(cancelAction);
		// Other plug-ins can insert new actions here
		manager.add(new Separator("Additions"));
	}

	// Create actions
	private void makeActions() {
		replaceAction = createAction(CorrectionViewAction.REPLACE, Messages
				.getString("SpellCorrectionView.Replace"), Messages
				.getString("SpellCorrectionView.Replace_occurrence"),
				SpellCheckerImages.IMG_REPLACE);
		replaceAllAction = createAction(
				CorrectionViewAction.REPLACEALL,
				Messages.getString("SpellCorrectionView.Replace_all"),
				Messages
						.getString("SpellCorrectionView.Replace_all_occurrences"),
				SpellCheckerImages.IMG_REPLACEALL);
		addToDictionaryAction = createAction(CorrectionViewAction.ADD, Messages
				.getString("SpellCorrectionView.Add_to_dictionary"), Messages
				.getString("SpellCorrectionView.Add_word_to_dictionary"),
				SpellCheckerImages.IMG_ADDTODICTIONARY);
		ignoreAction = createAction(CorrectionViewAction.IGNORE, Messages
				.getString("SpellCorrectionView.Ignore"), Messages
				.getString("SpellCorrectionView.Ignore_spelling_problem"),
				SpellCheckerImages.IMG_IGNORE);
		ignoreAllAction = createAction(CorrectionViewAction.IGNOREALL, Messages
				.getString("SpellCorrectionView.Ignore_all"), Messages
				.getString("SpellCorrectionView.Ignore_for_all_occurrences"),
				SpellCheckerImages.IMG_IGNOREALL);
		cancelAction = createAction(CorrectionViewAction.CANCEL, Messages
				.getString("SpellCorrectionView.StartCancel"), Messages
				.getString("SpellCorrectionView.StartCancel_spell_checking"),
				SpellCheckerImages.IMG_CANCEL);
		doubleClickAction = new CorrectionViewAction(this,
				CorrectionViewAction.DOUBLECLICK);
	}

	// Create a single action
	private IAction createAction(int operation, String label, String toolTip,
			String imageID) {
		IAction action = new CorrectionViewAction(this, operation);
		action.setText(label);
		action.setToolTipText(toolTip);
		SpellCheckerImages.setImageDescriptors(action, "lcl16", imageID);
		return action;
	}

	/**
	 * Perform operation for an action
	 * 
	 * @param operation -
	 *            the operation code
	 */
	public void performOperation(int operation) {
		if (currentEvent == null) {
			if (operation == CorrectionViewAction.CANCEL)
				// Start spell checking via action delegate
				SpellCheckerPlugin.getSpellCheckingActionDelegate().run(null);
			return;
		}
		switch (operation) {
		case CorrectionViewAction.DOUBLECLICK:
			if (!documentIsEditable)
				return;
			ISelection selection = viewer.getSelection();
			Object obj = ((IStructuredSelection) selection).getFirstElement();
			if (!(obj instanceof Word))
				return;
			currentEvent.replaceWord(obj.toString(), false);
			break;
		case CorrectionViewAction.REPLACE:
			currentEvent.replaceWord(badWord.getText(), false);
			break;
		case CorrectionViewAction.REPLACEALL:
			if (!documentIsEditable)
				return;
			currentEvent.replaceWord(badWord.getText(), true);
			break;
		case CorrectionViewAction.ADD:
			String newWord = badWord.getText();
			String originalBadWord = currentEvent.getInvalidWord();
			if (!documentIsEditable && !originalBadWord.equals(newWord))
				return;
			currentEvent.addToDictionary(newWord);
			break;
		case CorrectionViewAction.IGNORE:
			currentEvent.ignoreWord(false);
			break;
		case CorrectionViewAction.IGNOREALL:
			currentEvent.ignoreWord(true);
			break;
		case CorrectionViewAction.CANCEL:
			currentEvent.cancel();
			break;
		}
		signalEventProcessed();
	}

	// Signal end of event processing
	private void signalEventProcessed() {
		// Release waiting manager
		spellCheckManager.continueSpellChecking();
		// Reset current event
		currentEvent = null;
		// Update viewer
		updateView();
	}

	/**
	 * Update actions. Most of the actions are disabled when no more events are
	 * pending. The cancel action, however, now acts as a start action.
	 */
	public void updateActionEnablement() {
		boolean pendingEvent = (currentEvent != null);
		// Enable or disable actions
		if (pendingEvent & documentIsEditable) {
			boolean modified = !currentEvent.getInvalidWord().equals(
					badWord.getText());
			replaceAction.setEnabled(modified);
			replaceAllAction.setEnabled(modified);
		} else {
			replaceAction.setEnabled(false);
			replaceAllAction.setEnabled(false);
		}
		ignoreAction.setEnabled(pendingEvent);
		ignoreAllAction.setEnabled(pendingEvent);
		addToDictionaryAction.setEnabled(pendingEvent);
		// Update cancel action
		if (pendingEvent) {
			SpellCheckerImages.setImageDescriptors(cancelAction, "lcl16",
					SpellCheckerImages.IMG_CANCEL);
			cancelAction.setChecked(true);
			cancelAction.setToolTipText(Messages
					.getString("SpellCorrectionView.Cancel_spell_checking"));
			cancelAction.setEnabled(true);
		} else {
			SpellCheckerImages.setImageDescriptors(cancelAction, "lcl16",
					SpellCheckerImages.IMG_CHECK);
			cancelAction.setChecked(false);
			cancelAction.setToolTipText(Messages
					.getString("SpellCorrectionView.Start_spell_checking"));
			CheckSpellingActionDelegate delegate = SpellCheckerPlugin
					.getSpellCheckingActionDelegate();
			cancelAction.setEnabled(delegate != null && delegate.isEnabled());
		}
	}

	// Update view
	private void updateView() {
		// Execute via syncExec as we are called from other thread
		display.syncExec(new Runnable() {
			public void run() {
				// Update TableViewer
				viewer.setInput(currentEvent);
				// Update Text field and title
				if (currentEvent == null) {
					badWord.setText("");
					setContentDescription(spellCheckManager.getCurrentName()
							+ Messages.getString("SpellCorrectionView.done"));
				} else {
					badWord.setText(currentEvent.getInvalidWord());
					setContentDescription(spellCheckManager.getCurrentName()
							+ Messages
									.getString("SpellCorrectionView.in_progress"));
				}
				// Update actions
				updateActionEnablement();
			}
		});
	}

	/**
	 * Indicate that we are loading a dictionary
	 */
	public void indicateLoading(final String name) {
		display.syncExec(new Runnable() {
			public void run() {
				setContentDescription(name
						+ Messages.getString("SpellCorrectionView.loading"));
			}
		});
	}

	/**
	 * Supplies the Spell Correction View with a new spelling error event
	 * 
	 * @param event -
	 *            the spelling error event
	 * @param manager -
	 *            the manager to be notified when finished
	 * @param documentIsEditable -
	 *            true, if document may be modified
	 */
	public void setInput(SpellCheckEvent event, SpellCheckManager manager,
			boolean documentIsEditable) {
		// Accept event, manager, and flag
		this.currentEvent = event;
		this.spellCheckManager = manager;
		this.documentIsEditable = documentIsEditable;
		// Update the view
		updateView();
	}
}