org.odftoolkit.odfdom.incubator.search.Selection Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of odfdom-java Show documentation
ODFDOM is an OpenDocument Format (ODF) framework. Its purpose is to provide an easy common way to create, access and manipulate ODF files, without requiring detailed knowledge of the ODF specification. It is designed to provide the ODF developer community with an easy lightwork programming API portable to any object-oriented language. The current reference implementation is written in Java.
There is a newer version: 0.8.11-incubating
Show newest version
/************************************************************************
* 
*  Licensed to the Apache Software Foundation (ASF) under one
*  or more contributor license agreements.  See the NOTICE file
*  distributed with this work for additional information
*  regarding copyright ownership.  The ASF licenses this file
*  to you under the Apache License, Version 2.0 (the
*  "License"); you may not use this file except in compliance
*  with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing,
*  software distributed under the License is distributed on an
*  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
*  KIND, either express or implied.  See the License for the
*  specific language governing permissions and limitations
*  under the License.
*
************************************************************************/
package org.odftoolkit.odfdom.incubator.search;

import java.util.Hashtable;
import java.util.Vector;

import org.odftoolkit.odfdom.pkg.OdfElement;

/**
 * Abstract class Selection describe one of the matched results The selection
 * can be recognized by the container mElement, the start mIndex of the text
 * content of this mElement and the text content.
 * 
 * @deprecated As of release 0.8.8, replaced by {@link org.odftoolkit.simple.common.navigation.Selection} in Simple API.
 */
public abstract class Selection {

	private OdfElement mElement;
	private int mIndex;

	/**
	 * get the container mElement of this selection
	 * @return the container mElement
	 */
	public OdfElement getElement() {
		return mElement;
	}

	/**
	 * get the start mIndex of the text content of the container mElement
	 * this is only meaningful for TextSelection. other type Selection 
	 * will return 0.
	 * @return the start mIndex of the container mElement
	 */
	public int getIndex() {
		return mIndex;
	}

	/**
	 * cut the current selection
	 * @throws InvalidNavigationException 
	 */
	abstract public void cut() throws InvalidNavigationException;

	/**
	 * paste the current selection at front of the specified position selection
	 * @param positionitem	the position selection
	 * @throws InvalidNavigationException 
	 */
	abstract public void pasteAtFrontOf(Selection positionitem) throws InvalidNavigationException;

	/**
	 * paste the current selection at end of the specified position selection
	 * @param positionitem	the position selection
	 * @throws InvalidNavigationException 
	 */
	abstract public void pasteAtEndOf(Selection positionitem) throws InvalidNavigationException;

	/**
	 * when a selected item has been delete, the selections after this deleted selection should be refresh
	 * because these selections mIndex will be changed
	 * @param deleteditem	the deleted selection
	 */
	abstract protected void refreshAfterFrontalDelete(Selection deleteditem);

	/**
	 * when a selected item has been inserted, the selection after the inserted item should be refresh
	 * because these selections mIndex will be changed
	 * @param inserteditem	the inserted selection
	 */
	abstract protected void refreshAfterFrontalInsert(Selection inserteditem);

	/**
	 * A quick method to update the mIndex of this selection
	 * @param offset	the offset that the mIndex should be added
	 */
	abstract protected void refresh(int offset);

	/**
	 * SelectionManager can manage all the selections that are returned to end users.
	 * This SelectionManager contains a repository of all selections, and will refresh the status/mIndex
	 * of selections after certain operation.
	 */
	static class SelectionManager {

		static private Hashtable> repository = new Hashtable>();

		/**
		 * Register the selection item
		 * @param item	the selection item
		 */
		static public void registerItem(Selection item) {
			OdfElement element = item.getElement();
			if (repository.containsKey(element)) {
				Vector selections = repository.get(element);
				int i = 0;
				while (i < selections.size()) {
					if (selections.get(i).getIndex() > item.getIndex()) {
						selections.insertElementAt(item, i);
						break;
					}
					i++;
				}
				if (i == selections.size()) {
					selections.add(item);
				}
			} else {
				Vector al = new Vector();
				al.add(item);
				repository.put(element, al);
			}
		}

		/**
		 * Refresh the selections in repository after a item is cut.
		 * @param cutItem	the cut item
		 */
		synchronized static public void refreshAfterCut(Selection cutItem) {
			//travase the whole sub tree
			OdfElement element = cutItem.getElement();
			if (repository.containsKey(element)) {
				Vector selections = repository.get(element);
				for (int i = 0; i < selections.size(); i++) {
					if (selections.get(i).getIndex() > cutItem.getIndex()) {
						selections.get(i).refreshAfterFrontalDelete(cutItem);
					}
				}
			}
		}

		/**
		 * Refresh the selections in repository after a pastedAtFrontOf operation is called.
		 * @param item	the pasted item
		 * @param positionItem	the position item
		 */
		synchronized static public void refreshAfterPasteAtFrontOf(Selection item, Selection positionItem) {
			//travase the whole sub tree
			OdfElement element = positionItem.getElement();
			if (repository.containsKey(element)) {
				Vector selections = repository.get(element);
				for (int i = 0; i < selections.size(); i++) {
					if (selections.get(i).getIndex() >= positionItem.getIndex()) {
						selections.get(i).refreshAfterFrontalInsert(item);
					}
				}
			}
		}

		/**
		 * Refresh the selections in repository after a pastedAtEndOf operation is called.
		 * @param item	the pasted item
		 * @param positionItem	the position item
		 */
		synchronized static public void refreshAfterPasteAtEndOf(Selection item, Selection positionItem) {
			OdfElement element = positionItem.getElement();
			int positionIndex;

			if (positionItem instanceof TextSelection) {
				positionIndex = positionItem.getIndex() + ((TextSelection) positionItem).getText().length();
			} else {
				positionIndex = positionItem.getIndex();
			}

			if (repository.containsKey(element)) {
				Vector selections = repository.get(element);
				for (int i = 0; i < selections.size(); i++) {
					if (selections.get(i).getIndex() >= positionIndex) {
						selections.get(i).refreshAfterFrontalInsert(item);
					}
				}
			}
		}

		/**
		 * Remove the selection from repository.
		 * @param item	selection item
		 */
		static public void unregisterItem(Selection item) {
			OdfElement element = item.getElement();
			if (repository.containsKey(element)) {
				Vector selections = repository.get(element);
				selections.remove(item);
			}
		}

		/**
		 * A direct method to update all the selections contained in a mElement after a certain position.
		 * @param containerElement	the container mElement
		 * @param offset	the offset
		 * @param positionIndex	the mIndex of a certain position
		 */
		synchronized static public void refresh(OdfElement containerElement, int offset, int positionIndex) {
			if (repository.containsKey(containerElement)) {
				Vector selections = repository.get(containerElement);
				for (int i = 0; i < selections.size(); i++) {
					if (selections.get(i).getIndex() >= positionIndex) {
						selections.get(i).refresh(offset);
					}
				}
			}
		}

		private SelectionManager() {
		}
	}
}