bundles/org.eclipse.wst.sse.ui/src/org/eclipse/wst/sse/ui/internal/CaretMediator.java - sourceediting/webtools.sourceediting - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 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
  *     Jens Lukowski/Innoopract - initial renaming/restructuring
  *
  *******************************************************************************/
 package org.eclipse.wst.sse.ui.internal;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyledText;
 import org.eclipse.swt.events.KeyEvent;
 import org.eclipse.swt.events.KeyListener;
 import org.eclipse.swt.events.MouseEvent;
 import org.eclipse.swt.events.MouseListener;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Listener;
 import org.eclipse.wst.sse.core.internal.util.Debug;
 import org.eclipse.wst.sse.core.internal.util.Utilities;
 import org.eclipse.wst.sse.ui.internal.view.events.CaretEvent;
 import org.eclipse.wst.sse.ui.internal.view.events.ICaretListener;

 /**
  * Has the responsibility of listening for key events, and mouse events,
  * deciding if the caret has moved (without a text change), and if so, will
  * notify CaretListeners that the caret has moved. Objects which are
  * interested in ALL caret postion changes will also have to listen for
  * textChanged events.
  *
  * @deprecated - use base selection notification
  */
 public class CaretMediator implements Listener {

 	class CaretMediatorListener implements KeyListener, MouseListener {
 		public void keyPressed(KeyEvent e) {
 			internalKeyPressed(e);
 		}

 		public void keyReleased(KeyEvent e) {
 			internalKeyReleased(e);
 		}

 		public void mouseDoubleClick(MouseEvent e) {
 		}

 		public void mouseDown(MouseEvent e) {
 			internalMouseDown(e);
 		}

 		public void mouseUp(MouseEvent e) {
 			internalMouseUp(e);
 		}
 	}

 	class RefreshDelayJob extends Job {
 		private int fDelay = 0;
 		RefreshDelayJob(int delay) {
 			super(SSEUIMessages.caret_update); //$NON-NLS-1$
 			setSystem(true);
 			fDelay = delay;
 		}

 		/**
 		 * Setup a delayed CaretEvent firing
 		 */
 		void touch() {
 			cancel();
 			schedule(fDelay);
 		}

 		protected IStatus run(IProgressMonitor monitor) {
 			handleEvent(null);
 			return Status.OK_STATUS;
 		}
 	}

 	RefreshDelayJob fDelayer = null;
 	private static final int DELAY = 300;

 	/** used just for debug print outs */
 	private long endTime;
 	private long startTime;

 	protected ICaretListener[] fCaretListeners;
 	protected CaretMediatorListener internalListener;
 	protected StyledText textWidget;

 	/**
 	 * CaretMediator constructor comment.
 	 */
 	public CaretMediator() {
 		super();
 	}

 	/**
 	 * CaretMediator constructor comment. Must always provide the widget its
 	 * supposed to listen to.
 	 */
 	public CaretMediator(StyledText styledTextWidget) {
 		this();
 		setTextWidget(styledTextWidget);
 	}

 	public synchronized void addCaretListener(ICaretListener listener) {
 		if (Debug.debugStructuredDocument) {
 			System.out.println("CaretMediator::addCaretListener. Request to add an instance of " + listener.getClass() + " as a listener on caretlistner.");//$NON-NLS-2$//$NON-NLS-1$
 		}
 		// make sure listener is not already in listening array
 		// (and if it is, print a warning to aid debugging, if needed)

 		if (Utilities.contains(fCaretListeners, listener)) {
 			if (Debug.displayWarnings) {
 				System.out.println("CaretMediator::addCaretListener. listener " + listener + " was added more than once. ");//$NON-NLS-2$//$NON-NLS-1$
 			}
 		} else {
 			if (Debug.debugStructuredDocument) {
 				System.out.println("CaretMediator::addCaretListener. Adding an instance of " + listener.getClass() + " as a listener on caret mediator.");//$NON-NLS-2$//$NON-NLS-1$
 			}
 			int oldSize = 0;
 			if (fCaretListeners != null) {
 				// normally won't be null, but we need to be sure, for first
 				// time through
 				oldSize = fCaretListeners.length;
 			}
 			int newSize = oldSize + 1;
 			ICaretListener[] newListeners = new ICaretListener[newSize];
 			if (fCaretListeners != null) {
 				System.arraycopy(fCaretListeners, 0, newListeners, 0, oldSize);
 			}
 			// add listener to last position
 			newListeners[newSize - 1] = listener;
 			//
 			// now switch new for old
 			fCaretListeners = newListeners;

 		}
 	}

 	protected void fireCaretEvent(CaretEvent event) {
 		if (fCaretListeners != null) {
 			// we must assign listeners to local variable to be thread safe,
 			// since the add and remove listner methods
 			// can change this object's actual instance of the listener array
 			// from another thread
 			// (and since object assignment is atomic, we don't need to
 			// synchronize
 			ICaretListener[] holdListeners = fCaretListeners;
 			//
 			for (int i = 0; i < holdListeners.length; i++) {
 				holdListeners[i].caretMoved(event);
 			}
 		}
 	}

 	public void handleEvent(Event e) {
 		Display display = null;

 		if (Debug.debugCaretMediator) {
 			endTime = System.currentTimeMillis();
 			System.out.println("Timer fired: " + (endTime - startTime)); //$NON-NLS-1$
 		}

 		// check if 'okToUse'
 		if (textWidget != null && !textWidget.isDisposed()) {
 			display = textWidget.getDisplay();
 			if ((display != null) && (!display.isDisposed())) {
 				display.asyncExec(new Runnable() {
 					public void run() {
 						if (textWidget != null && !textWidget.isDisposed()) {
 							fireCaretEvent(new CaretEvent(textWidget, textWidget.getCaretOffset()));
 						}
 					}
 				});
 			}
 		}
 	}

 	protected void internalKeyPressed(KeyEvent e) {
 		fDelayer.cancel();
 	}

 	protected void internalKeyReleased(KeyEvent e) {
 		switch (e.keyCode) {
 			case SWT.ARROW_DOWN :
 			case SWT.ARROW_UP :
 			case SWT.ARROW_LEFT :
 			case SWT.ARROW_RIGHT :
 			case SWT.HOME :
 			case SWT.END :
 			case SWT.PAGE_DOWN :
 			case SWT.PAGE_UP : {
 				fDelayer.touch();
 				break;
 			}
 			default : {
 				// always update cursor postion, even during normal typing
 				// (the logic may look funny, since we always to the same
 				// thing, but we haven't always done the same thing, so I
 				// wanted to leave that fact documented via code.)
 				fDelayer.touch();
 			}
 		}
 	}

 	protected void internalMouseDown(MouseEvent e) {
 		fDelayer.cancel();
 	}

 	protected void internalMouseUp(MouseEvent e) {
 		// Note, even during a swipe select, when the mouse button goes up,
 		// and the widget is
 		// queried for the current caret postion, it always returns the
 		// beginning of the selection,
 		// which is desirable (at least for the known use of this feature,
 		// which is to signal
 		// that the property sheet can update itself.
 		fDelayer.touch();
 	}

 	public void release() {
 		fDelayer.cancel();
 		if (textWidget != null && !textWidget.isDisposed()) {
 			textWidget.removeKeyListener(internalListener);
 			textWidget.removeMouseListener(internalListener);
 			textWidget = null;
 		}
 	}

 	public synchronized void removeCaretListener(ICaretListener listener) {
 		if ((fCaretListeners != null) && (listener != null)) {
 			// if its not in the listeners, we'll ignore the request
 			if (Utilities.contains(fCaretListeners, listener)) {
 				int oldSize = fCaretListeners.length;
 				int newSize = oldSize - 1;
 				ICaretListener[] newListeners = new ICaretListener[newSize];
 				int index = 0;
 				for (int i = 0; i < oldSize; i++) {
 					if (fCaretListeners[i] == listener) { // ignore
 					} else {
 						// copy old to new if its not the one we are removing
 						newListeners[index++] = fCaretListeners[i];
 					}
 				}
 				// now that we have a new array, let's switch it for the old
 				// one
 				fCaretListeners = newListeners;
 			}
 		}
 	}

 	public void setTextWidget(StyledText newTextWidget) {
 		if(fDelayer == null) {
 			fDelayer = new RefreshDelayJob(DELAY);
 		}

 		// unhook from previous, if any
 		if (this.textWidget != null) {
 			fDelayer.cancel();
 			this.textWidget.removeKeyListener(internalListener);
 			this.textWidget.removeMouseListener(internalListener);
 		}

 		this.textWidget = newTextWidget;

 		if (internalListener == null) {
 			internalListener = new CaretMediatorListener();
 		}

 		if (this.textWidget != null) {
 			this.textWidget.addKeyListener(internalListener);
 			this.textWidget.addMouseListener(internalListener);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 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
	* Jens Lukowski/Innoopract - initial renaming/restructuring
	*
	*******************************************************************************/
	package org.eclipse.wst.sse.ui.internal;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.core.runtime.jobs.Job;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.StyledText;
	import org.eclipse.swt.events.KeyEvent;
	import org.eclipse.swt.events.KeyListener;
	import org.eclipse.swt.events.MouseEvent;
	import org.eclipse.swt.events.MouseListener;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Event;
	import org.eclipse.swt.widgets.Listener;
	import org.eclipse.wst.sse.core.internal.util.Debug;
	import org.eclipse.wst.sse.core.internal.util.Utilities;
	import org.eclipse.wst.sse.ui.internal.view.events.CaretEvent;
	import org.eclipse.wst.sse.ui.internal.view.events.ICaretListener;

	/**
	* Has the responsibility of listening for key events, and mouse events,
	* deciding if the caret has moved (without a text change), and if so, will
	* notify CaretListeners that the caret has moved. Objects which are
	* interested in ALL caret postion changes will also have to listen for
	* textChanged events.
	*
	* @deprecated - use base selection notification
	*/
	public class CaretMediator implements Listener {

	class CaretMediatorListener implements KeyListener, MouseListener {
	public void keyPressed(KeyEvent e) {
	internalKeyPressed(e);
	}

	public void keyReleased(KeyEvent e) {
	internalKeyReleased(e);
	}

	public void mouseDoubleClick(MouseEvent e) {
	}

	public void mouseDown(MouseEvent e) {
	internalMouseDown(e);
	}

	public void mouseUp(MouseEvent e) {
	internalMouseUp(e);
	}
	}

	class RefreshDelayJob extends Job {
	private int fDelay = 0;
	RefreshDelayJob(int delay) {
	super(SSEUIMessages.caret_update); //$NON-NLS-1$
	setSystem(true);
	fDelay = delay;
	}

	/**
	* Setup a delayed CaretEvent firing
	*/
	void touch() {
	cancel();
	schedule(fDelay);
	}

	protected IStatus run(IProgressMonitor monitor) {
	handleEvent(null);
	return Status.OK_STATUS;
	}
	}

	RefreshDelayJob fDelayer = null;
	private static final int DELAY = 300;

	/** used just for debug print outs */
	private long endTime;
	private long startTime;

	protected ICaretListener[] fCaretListeners;
	protected CaretMediatorListener internalListener;
	protected StyledText textWidget;

	/**
	* CaretMediator constructor comment.
	*/
	public CaretMediator() {
	super();
	}

	/**
	* CaretMediator constructor comment. Must always provide the widget its
	* supposed to listen to.
	*/
	public CaretMediator(StyledText styledTextWidget) {
	this();
	setTextWidget(styledTextWidget);
	}

	public synchronized void addCaretListener(ICaretListener listener) {
	if (Debug.debugStructuredDocument) {
	System.out.println("CaretMediator::addCaretListener. Request to add an instance of " + listener.getClass() + " as a listener on caretlistner.");//$NON-NLS-2$//$NON-NLS-1$
	}
	// make sure listener is not already in listening array
	// (and if it is, print a warning to aid debugging, if needed)

	if (Utilities.contains(fCaretListeners, listener)) {
	if (Debug.displayWarnings) {
	System.out.println("CaretMediator::addCaretListener. listener " + listener + " was added more than once. ");//$NON-NLS-2$//$NON-NLS-1$
	}
	} else {
	if (Debug.debugStructuredDocument) {
	System.out.println("CaretMediator::addCaretListener. Adding an instance of " + listener.getClass() + " as a listener on caret mediator.");//$NON-NLS-2$//$NON-NLS-1$
	}
	int oldSize = 0;
	if (fCaretListeners != null) {
	// normally won't be null, but we need to be sure, for first
	// time through
	oldSize = fCaretListeners.length;
	}
	int newSize = oldSize + 1;
	ICaretListener[] newListeners = new ICaretListener[newSize];
	if (fCaretListeners != null) {
	System.arraycopy(fCaretListeners, 0, newListeners, 0, oldSize);
	}
	// add listener to last position
	newListeners[newSize - 1] = listener;
	//
	// now switch new for old
	fCaretListeners = newListeners;

	}
	}

	protected void fireCaretEvent(CaretEvent event) {
	if (fCaretListeners != null) {
	// we must assign listeners to local variable to be thread safe,
	// since the add and remove listner methods
	// can change this object's actual instance of the listener array
	// from another thread
	// (and since object assignment is atomic, we don't need to
	// synchronize
	ICaretListener[] holdListeners = fCaretListeners;
	//
	for (int i = 0; i < holdListeners.length; i++) {
	holdListeners[i].caretMoved(event);
	}
	}
	}

	public void handleEvent(Event e) {
	Display display = null;

	if (Debug.debugCaretMediator) {
	endTime = System.currentTimeMillis();
	System.out.println("Timer fired: " + (endTime - startTime)); //$NON-NLS-1$
	}

	// check if 'okToUse'
	if (textWidget != null && !textWidget.isDisposed()) {
	display = textWidget.getDisplay();
	if ((display != null) && (!display.isDisposed())) {
	display.asyncExec(new Runnable() {
	public void run() {
	if (textWidget != null && !textWidget.isDisposed()) {
	fireCaretEvent(new CaretEvent(textWidget, textWidget.getCaretOffset()));
	}
	}
	});
	}
	}
	}

	protected void internalKeyPressed(KeyEvent e) {
	fDelayer.cancel();
	}

	protected void internalKeyReleased(KeyEvent e) {
	switch (e.keyCode) {
	case SWT.ARROW_DOWN :
	case SWT.ARROW_UP :
	case SWT.ARROW_LEFT :
	case SWT.ARROW_RIGHT :
	case SWT.HOME :
	case SWT.END :
	case SWT.PAGE_DOWN :
	case SWT.PAGE_UP : {
	fDelayer.touch();
	break;
	}
	default : {
	// always update cursor postion, even during normal typing
	// (the logic may look funny, since we always to the same
	// thing, but we haven't always done the same thing, so I
	// wanted to leave that fact documented via code.)
	fDelayer.touch();
	}
	}
	}

	protected void internalMouseDown(MouseEvent e) {
	fDelayer.cancel();
	}

	protected void internalMouseUp(MouseEvent e) {
	// Note, even during a swipe select, when the mouse button goes up,
	// and the widget is
	// queried for the current caret postion, it always returns the
	// beginning of the selection,
	// which is desirable (at least for the known use of this feature,
	// which is to signal
	// that the property sheet can update itself.
	fDelayer.touch();
	}

	public void release() {
	fDelayer.cancel();
	if (textWidget != null && !textWidget.isDisposed()) {
	textWidget.removeKeyListener(internalListener);
	textWidget.removeMouseListener(internalListener);
	textWidget = null;
	}
	}

	public synchronized void removeCaretListener(ICaretListener listener) {
	if ((fCaretListeners != null) && (listener != null)) {
	// if its not in the listeners, we'll ignore the request
	if (Utilities.contains(fCaretListeners, listener)) {
	int oldSize = fCaretListeners.length;
	int newSize = oldSize - 1;
	ICaretListener[] newListeners = new ICaretListener[newSize];
	int index = 0;
	for (int i = 0; i < oldSize; i++) {
	if (fCaretListeners[i] == listener) { // ignore
	} else {
	// copy old to new if its not the one we are removing
	newListeners[index++] = fCaretListeners[i];
	}
	}
	// now that we have a new array, let's switch it for the old
	// one
	fCaretListeners = newListeners;
	}
	}
	}

	public void setTextWidget(StyledText newTextWidget) {
	if(fDelayer == null) {
	fDelayer = new RefreshDelayJob(DELAY);
	}

	// unhook from previous, if any
	if (this.textWidget != null) {
	fDelayer.cancel();
	this.textWidget.removeKeyListener(internalListener);
	this.textWidget.removeMouseListener(internalListener);
	}

	this.textWidget = newTextWidget;

	if (internalListener == null) {
	internalListener = new CaretMediatorListener();
	}

	if (this.textWidget != null) {
	this.textWidget.addKeyListener(internalListener);
	this.textWidget.addMouseListener(internalListener);
	}
	}
	}