plugins/org.eclipse.actf.ai.fennec/src/org/eclipse/actf/ai/fennec/treemanager/impl/TreeManagerImpl.java - actf/org.eclipse.actf.ai - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007 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:
  *    Hisashi MIYASHITA - initial API and implementation
  *******************************************************************************/
 package org.eclipse.actf.ai.fennec.treemanager.impl;

 import java.util.ArrayList;

 import org.eclipse.actf.ai.fennec.IFennecService;
 import org.eclipse.actf.ai.fennec.FennecException;
 import org.eclipse.actf.ai.fennec.FennecInterruptedException;
 import org.eclipse.actf.ai.fennec.treemanager.IAccessKeyList;
 import org.eclipse.actf.ai.fennec.treemanager.ILocation;
 import org.eclipse.actf.ai.fennec.treemanager.ISoundControl;
 import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
 import org.eclipse.actf.ai.fennec.treemanager.ITreeManager;
 import org.eclipse.actf.ai.fennec.treemanager.IVideoControl;
 import org.eclipse.actf.ai.fennec.treemanager.TreeManagerException;
 import org.eclipse.actf.ai.fennec.treemanager.TreeManagerInterruptedException;
 import org.eclipse.actf.model.dom.dombycom.IFlashNode;
 import org.eclipse.actf.util.vocab.IProposition;
 import org.eclipse.actf.util.vocab.Vocabulary;


 /**
  * The main plugin class to be used in the desktop.
  */
 public class TreeManagerImpl implements ITreeManager {
     private IFennecService fennecService;

     public TreeManagerImpl(IFennecService fennecService) {
         this.fennecService = fennecService;
     }

     public int getLevel() throws TreeManagerException {
         int i = 0;
         ITreeItem ita = getActiveItem();
         if (ita == null)
             return 0;
         while (true) {
             ita = ita.getParent();
             if (ita == null)
                 break;
             i++;
         }
         return i;
     }

     public ITreeItem getActiveItem() throws TreeManagerException {
         return fennecService.getLastTreeItem();
     }

     public ITreeItem[] getSiblings() throws TreeManagerException {
         ITreeItem item = getActiveItem();
         if (item == null)
             return null;
         ITreeItem parent = item.getParent();
         if (parent == null) {
             ITreeItem[] itas = new ITreeItem[1];
             itas[0] = getActiveItem();
             return itas;
         }
         return parent.getChildItems();
     }

     private void initFennecService() throws TreeManagerException {
         if (fennecService.getStatus() == IFennecService.NORMAL)
             return;
         try {
             fennecService.initialize();
         } catch (FennecInterruptedException e) {
             throw new TreeManagerInterruptedException(ITreeManager.UNDONE, e.getMessage(), e);
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, e.getMessage(), e);
         }
     }

     public int initialize() throws TreeManagerException {
         initFennecService();
         return ITreeManager.NOACTION;
     }

     private int moveUpdate(ITreeItem target, boolean update) throws TreeManagerException {
         try {
             return fennecService.moveUpdate(target, update);
         } catch (FennecInterruptedException e) {
             throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to update by move.", e);
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to update by move.", e);
         }
     }

     private int clickUpdate(ITreeItem target) throws TreeManagerException {
         try {
             return fennecService.clickUpdate(target);
         } catch (FennecInterruptedException e) {
             throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to update by click.", e);
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to update by click.", e);
         }
     }

     private int gotoRoot() throws TreeManagerException {
         ITreeItem parent = getActiveItem().getParent();
         if (parent == null)
             return ITreeManager.NOACTION;
         while (gotoParent() != ITreeManager.NOACTION)
             ;
         return ITreeManager.MOVED | ITreeManager.LEVEL_CHANGED;
     }

     public int stay() throws TreeManagerException {
         initFennecService();
         return getActiveItem().stay();
     }

     public int click(boolean doClick) throws TreeManagerException {
         initFennecService();
         ITreeItem item = getActiveItem();
         if (doClick)
             item.doClick();
         return clickUpdate(item);
     }

     public int gotoParent() throws TreeManagerException {
         initFennecService();
         ITreeItem parent = getActiveItem().getParent();
         if (parent != null) {
             int st = moveUpdate(parent, true);
             if ((st & ITreeManager.MOVED) != 0)
                 st |= ITreeManager.LEVEL_CHANGED;
             return st;
         }
         return ITreeManager.NOACTION;
     }

     public int gotoFirstChild() throws TreeManagerException {
         initFennecService();
         ITreeItem active = getActiveItem();
         ITreeItem[] childItems = active.getChildItems();
         if (childItems.length == 0)
             return ITreeManager.NOACTION;
         int st = moveUpdate(childItems[0], true);
         if ((st & ITreeManager.MOVED) != 0)
             st |= ITreeManager.LEVEL_CHANGED;
         return st;
     }

     private int gotoLastChild() throws TreeManagerException {
         initFennecService();
         ITreeItem active = getActiveItem();
         ITreeItem[] childItems = active.getChildItems();
         if (childItems.length == 0)
             return ITreeManager.NOACTION;
         int st = moveUpdate(childItems[childItems.length - 1], true);
         if ((st & ITreeManager.MOVED) != 0)
             st |= ITreeManager.LEVEL_CHANGED;
         return st;
     }

     private int gotoSiblingIndex(int idx) throws TreeManagerException {
         initFennecService();
         ITreeItem active = getActiveItem();
         ITreeItem[] siblingItems = getSiblings();
         if ((idx < 0) || (siblingItems.length <= idx) || (active.equals(siblingItems[idx])))
             return ITreeManager.NOACTION;
         int st = moveUpdate(siblingItems[idx], true);
         return st;
     }

     private int getActiveIndex() throws TreeManagerException {
         initFennecService();
         return getActiveItem().getNth();
     }

     public int gotoStartOfSiblings() throws TreeManagerException {
         return gotoSiblingIndex(0);
     }

     public int gotoEndOfSiblings() throws TreeManagerException {
         initFennecService();
         ITreeItem[] siblingItems = getSiblings();
         int st = moveUpdate(siblingItems[siblingItems.length - 1], true);
         return st | ITreeManager.MOVED;
     }

     public int gotoPreviousSibling() throws TreeManagerException {
         int idx = getActiveIndex();
         return gotoSiblingIndex(idx - 1);
     }

     public int gotoNextSibling() throws TreeManagerException {
         int idx = getActiveIndex();
         return gotoSiblingIndex(idx + 1);
     }

     public int gotoStartOfPage() throws TreeManagerException {
         ITreeItem item = getCurrentRootItem();
         int st;
         st = moveUpdate(item, true);
         return ITreeManager.NOACTION;

         /*
          ITreeItem[] childItems = item.getChildItems();
          int st;
          if ((childItems != null) && (childItems.length > 0)) {
          st = moveUpdate(childItems[0], true);
          } else {
          st = moveUpdate(item, true);
          }
          if ((st & ITreeManager.MOVED) != 0)
          st |= ITreeManager.LEVEL_CHANGED;
          return st;*/
     }

     public int gotoEndOfPageForFind() throws TreeManagerException {
         // TODO
         int st;
         this.gotoStartOfPage();
         do {
             st = this.gotoEndOfSiblings();
         } while (this.gotoFirstChild() != ITreeManager.NOACTION);

         if ((st & ITreeManager.MOVED) != 0)
             st |= ITreeManager.LEVEL_CHANGED;
         return st;
     }

     public int gotoEndOfPage() throws TreeManagerException {
         // TODO
         int st;
         this.gotoStartOfPage();
         do {
             st = this.gotoEndOfSiblings();
         } while (this.gotoFirstChild() != ITreeManager.NOACTION);

         ITreeItem item = getActiveItem();
         while (!Vocabulary.hasReadingContent().eval(item)) {
             st = this.traverse(true);
             item = getActiveItem();
         }

         if ((st & ITreeManager.MOVED) != 0)
             st |= ITreeManager.LEVEL_CHANGED;
         return st;
     }

     public int gotoPreviousLine() throws TreeManagerException {
         // TODO
         return ITreeManager.NOACTION;
     }

     public int gotoNextLine() throws TreeManagerException {
         // TODO
         return ITreeManager.NOACTION;
     }

     public int gotoStartOfLine() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int gotoEndOfLine() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     private int findItem(boolean back, IProposition proposition) throws TreeManagerException {
         try {
             ITreeItem item;
             int[] pos = getActivePos();
             int level = pos.length;
             int rc;
             if (back) {
                 // First, traverse to the next item in order to skip the items
                 // connectable with the current item.
                 rc = traverse(true);
                 item = getActiveItem();
                 if (proposition.eval(item)) {
                     rc |= ITreeManager.FOUND;
                 } else {
                     rc = fennecService.searchBackward(proposition);
                 }
             } else {
                 // Likewise.
                 rc = traverse(false);
                 item = getActiveItem();
                 if (proposition.eval(item)) {
                     rc |= ITreeManager.FOUND;
                 } else {
                     rc = fennecService.searchForward(proposition);
                 }
             }
             if ((rc & ITreeManager.FOUND) == 0) {
                 setActivePos(pos);
                 return rc;
             }
             item = getActiveItem();
             if (back) {
                 // Skip to the interval start.
                 ITreeItem siblings[] = getSiblings();
                 int idx = item.getNth();
                 int st = intervalStart(siblings, idx);
                 if (idx != st) {
                     rc |= moveUpdate(siblings[st], false);
                 }
                 item = getActiveItem();
             }
             if (!Vocabulary.hasReadingContent().eval(item)) {
                 traverse(false);
             }
             if (level != getLevel()) {
                 rc |= ITreeManager.LEVEL_CHANGED;
             }
             return rc;
         } catch (FennecInterruptedException e) {
             throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to search.", e);
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to search.", e);
         }
     }

     private int[] getActivePos() throws TreeManagerException {
         int[] ret = new int[getLevel()];
         ITreeItem current = getActiveItem();
         int count = ret.length;
         while (count > 0) {
             ret[count - 1] = current.getNth();
             count--;
             current = current.getParent();
         }
         return ret;
     }

     private int setActivePos(int[] indexes) throws TreeManagerException {
         gotoRoot();
         ITreeItem item;
         int st = ITreeManager.NOACTION;
         for (int i = 0; i < indexes.length; i++) {
             item = getActiveItem();
             ITreeItem[] children = item.getChildItems();
             int idx = indexes[i];
             if ((children == null) || (idx >= children.length))
                 break;
             st |= moveUpdate(children[idx], true);
         }
         return st;
     }

     public int findNext(IProposition proposition) throws TreeManagerException {
         return findItem(false, proposition);
     }

     public int findPrevious(IProposition proposition) throws TreeManagerException {
         return findItem(true, proposition);
     }

     private int traverseForward(ITreeItem active) throws TreeManagerException {
         ITreeItem[] childItems = active.getChildItems();
         if (childItems.length != 0) {
             int st = moveUpdate(childItems[0], false);
             return st;
         }
         int idx = active.getNth();
         ITreeItem[] siblings = getSiblings();
         if ((idx >= 0) && ((idx + 1) < siblings.length)) {
             int st = moveUpdate(siblings[idx + 1], false);
             return st;
         }

         for (int upCount = 1;; upCount++) {
             active = getActiveItem();
             ITreeItem parent = active.getParent();
             if (parent == null) {
                 for (; upCount > 0; upCount--) {
                     gotoLastChild();
                 }
                 return ITreeManager.NOACTION;
             }
             if (moveUpdate(parent, false) == ITreeManager.NOACTION) {
                 throw new TreeManagerException(ITreeManager.ERROR, "Internal Error.");
             }
             idx = getActiveIndex();
             siblings = getSiblings();
             if ((idx >= 0) && ((idx + 1) < siblings.length)) {
                 int st = moveUpdate(siblings[idx + 1], false);
                 return st;
             }
         }
     }

     private int traverseBackward() throws TreeManagerException {
         int idx = getActiveIndex();
         if (idx <= 0) {
             ITreeItem active = getActiveItem();
             ITreeItem parent = active.getParent();
             if (parent == null)
                 return ITreeManager.NOACTION;
             int st = moveUpdate(parent, false);
             return st;
         }
         ITreeItem[] siblings = getSiblings();
         int st = moveUpdate(siblings[idx - 1], false);

         for (;;) {
             ITreeItem active = getActiveItem();
             ITreeItem[] childItems = active.getChildItems();
             if (childItems.length == 0)
                 break;
             st |= moveUpdate(childItems[0], false) | ITreeManager.LEVEL_CHANGED;
             siblings = getSiblings();
             if (siblings.length > 1) {
                 st |= moveUpdate(siblings[siblings.length - 1], false);
             }
         }
         return st;
     }

     private int intervalStart(ITreeItem[] siblings, int st) {
         for (st = st - 1;; st--) {
             if (st < 0)
                 return 0;
             if (!Vocabulary.isConnectable().eval(siblings[st]))
                 return st + 1;
         }
     }

     private int intervalEnd(ITreeItem[] siblings, int end) {
         for (; end < siblings.length; end++) {
             if (!Vocabulary.isConnectable().eval(siblings[end]))
                 return end;
         }
         return end - 1;
     }

     public int traverse(boolean back) throws TreeManagerException {
         initFennecService();
         ITreeItem orig = getActiveItem();
         ITreeItem current = orig;
         int level = getLevel();
         int rc = ITreeManager.NOACTION;

         if (back) {
             do {
                 rc = traverseBackward();
                 current = getActiveItem();
             } while ((rc != ITreeManager.NOACTION)
                     && (!Vocabulary.hasReadingContent().eval(current)));
             ITreeItem siblings[] = getSiblings();
             int idx = current.getNth();
             int st = intervalStart(siblings, idx);
             if (idx != st) {
                 rc |= moveUpdate(siblings[st], false);
             }
         } else {
             ITreeItem siblings[] = getSiblings();
             int idx = current.getNth();
             int end = intervalEnd(siblings, idx);
             current = siblings[end];
             do {
                 rc = traverseForward(current);
                 current = getActiveItem();
             } while ((rc != ITreeManager.NOACTION)
                     && (!Vocabulary.hasReadingContent().eval(current)));
         }

         if (!orig.equals(current)) {
             // rc |= ITreeManager.MOVED;
             if (level != getLevel()) {
                 rc |= ITreeManager.LEVEL_CHANGED;
             }
         }

         return rc;
     }

     public String[] getActiveStrings() throws TreeManagerException {
         initFennecService();
         ArrayList al = new ArrayList();
         ITreeItem[] siblings = getSiblings();
         for (int i = getActiveIndex(); i < siblings.length; i++) {
             ITreeItem current = siblings[i];
             String str = current.getUIString();
             if (str.length() > 0) {
                 al.add(str);
             }
             ITreeItem[] childItems = current.getChildItems();
             if (childItems.length > 0)
                 break;
         }
         return (String[]) al.toArray(new String[0]);
     }

     public int gotoLeftCell() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int gotoRightCell() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int gotoUpCell() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int gotoDownCell() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int getActiveTableInfo() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public int getActiveTableCellInfo() throws TreeManagerException {
         // TODO Auto-generated method stub
         return 0;
     }

     public ITreeItem getCurrentRootItem() throws TreeManagerException {
         initFennecService();
         ITreeItem parent, current;
         current = getActiveItem();
         while (true) {
             parent = current.getParent();
             if (parent == null)
                 break;
             current = parent;
         }
         return current;
     }

     public ISoundControl getSoundControl() throws TreeManagerException {
         initFennecService();
         return fennecService.getSoundControl();
     }

     public IVideoControl getVideoControl() throws TreeManagerException {
         initFennecService();
         return fennecService.getVideoControl();
     }

     public IAccessKeyList getAccessKeyList() throws TreeManagerException {
         initFennecService();
         return fennecService.getAccessKeyList();
     }

     public int analyze() throws TreeManagerException {
         initFennecService();
         try {
             return fennecService.analyze();
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to analyze", e);
         }
     }

     public ILocation getCurrentLocation() throws TreeManagerException {
         initFennecService();
         return new LocationImpl(getActivePos());
     }

     public int moveToLocation(ILocation location) throws TreeManagerException {
         initFennecService();
         LocationImpl loc = (LocationImpl) location;
         int[] pos = loc.getPos();
         return setActivePos(pos);
     }

     public ITreeItem expandWholeTree() throws TreeManagerException {
         initFennecService();
         try {
             return fennecService.expandWholeTree();
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to expand the whole tree", e);
         }
     }

     public int skipToAnchor(String target) throws TreeManagerException {
         initFennecService();
         try {
             return fennecService.skipToAnchor(target);
         } catch (FennecException e) {
             throw new TreeManagerException(ITreeManager.ERROR, "Failed to find the target in the anchors", e);
         }
     }

     public void repairFlash() throws TreeManagerException {
         initFennecService();
         IFlashNode[] node = fennecService.getFlashTopNodes();
         for (int i = 0; i < node.length; i++) {
             node[i].repairFlash();
         }
     }
 }
	/*******************************************************************************
	* Copyright (c) 2007 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:
	* Hisashi MIYASHITA - initial API and implementation
	*******************************************************************************/
	package org.eclipse.actf.ai.fennec.treemanager.impl;

	import java.util.ArrayList;

	import org.eclipse.actf.ai.fennec.IFennecService;
	import org.eclipse.actf.ai.fennec.FennecException;
	import org.eclipse.actf.ai.fennec.FennecInterruptedException;
	import org.eclipse.actf.ai.fennec.treemanager.IAccessKeyList;
	import org.eclipse.actf.ai.fennec.treemanager.ILocation;
	import org.eclipse.actf.ai.fennec.treemanager.ISoundControl;
	import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
	import org.eclipse.actf.ai.fennec.treemanager.ITreeManager;
	import org.eclipse.actf.ai.fennec.treemanager.IVideoControl;
	import org.eclipse.actf.ai.fennec.treemanager.TreeManagerException;
	import org.eclipse.actf.ai.fennec.treemanager.TreeManagerInterruptedException;
	import org.eclipse.actf.model.dom.dombycom.IFlashNode;
	import org.eclipse.actf.util.vocab.IProposition;
	import org.eclipse.actf.util.vocab.Vocabulary;


	/**
	* The main plugin class to be used in the desktop.
	*/
	public class TreeManagerImpl implements ITreeManager {
	private IFennecService fennecService;

	public TreeManagerImpl(IFennecService fennecService) {
	this.fennecService = fennecService;
	}

	public int getLevel() throws TreeManagerException {
	int i = 0;
	ITreeItem ita = getActiveItem();
	if (ita == null)
	return 0;
	while (true) {
	ita = ita.getParent();
	if (ita == null)
	break;
	i++;
	}
	return i;
	}

	public ITreeItem getActiveItem() throws TreeManagerException {
	return fennecService.getLastTreeItem();
	}

	public ITreeItem[] getSiblings() throws TreeManagerException {
	ITreeItem item = getActiveItem();
	if (item == null)
	return null;
	ITreeItem parent = item.getParent();
	if (parent == null) {
	ITreeItem[] itas = new ITreeItem[1];
	itas[0] = getActiveItem();
	return itas;
	}
	return parent.getChildItems();
	}

	private void initFennecService() throws TreeManagerException {
	if (fennecService.getStatus() == IFennecService.NORMAL)
	return;
	try {
	fennecService.initialize();
	} catch (FennecInterruptedException e) {
	throw new TreeManagerInterruptedException(ITreeManager.UNDONE, e.getMessage(), e);
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, e.getMessage(), e);
	}
	}

	public int initialize() throws TreeManagerException {
	initFennecService();
	return ITreeManager.NOACTION;
	}

	private int moveUpdate(ITreeItem target, boolean update) throws TreeManagerException {
	try {
	return fennecService.moveUpdate(target, update);
	} catch (FennecInterruptedException e) {
	throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to update by move.", e);
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to update by move.", e);
	}
	}

	private int clickUpdate(ITreeItem target) throws TreeManagerException {
	try {
	return fennecService.clickUpdate(target);
	} catch (FennecInterruptedException e) {
	throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to update by click.", e);
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to update by click.", e);
	}
	}

	private int gotoRoot() throws TreeManagerException {
	ITreeItem parent = getActiveItem().getParent();
	if (parent == null)
	return ITreeManager.NOACTION;
	while (gotoParent() != ITreeManager.NOACTION)
	;
	return ITreeManager.MOVED \| ITreeManager.LEVEL_CHANGED;
	}

	public int stay() throws TreeManagerException {
	initFennecService();
	return getActiveItem().stay();
	}

	public int click(boolean doClick) throws TreeManagerException {
	initFennecService();
	ITreeItem item = getActiveItem();
	if (doClick)
	item.doClick();
	return clickUpdate(item);
	}

	public int gotoParent() throws TreeManagerException {
	initFennecService();
	ITreeItem parent = getActiveItem().getParent();
	if (parent != null) {
	int st = moveUpdate(parent, true);
	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;
	}
	return ITreeManager.NOACTION;
	}

	public int gotoFirstChild() throws TreeManagerException {
	initFennecService();
	ITreeItem active = getActiveItem();
	ITreeItem[] childItems = active.getChildItems();
	if (childItems.length == 0)
	return ITreeManager.NOACTION;
	int st = moveUpdate(childItems[0], true);
	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;
	}

	private int gotoLastChild() throws TreeManagerException {
	initFennecService();
	ITreeItem active = getActiveItem();
	ITreeItem[] childItems = active.getChildItems();
	if (childItems.length == 0)
	return ITreeManager.NOACTION;
	int st = moveUpdate(childItems[childItems.length - 1], true);
	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;
	}

	private int gotoSiblingIndex(int idx) throws TreeManagerException {
	initFennecService();
	ITreeItem active = getActiveItem();
	ITreeItem[] siblingItems = getSiblings();
	if ((idx < 0) \|\| (siblingItems.length <= idx) \|\| (active.equals(siblingItems[idx])))
	return ITreeManager.NOACTION;
	int st = moveUpdate(siblingItems[idx], true);
	return st;
	}

	private int getActiveIndex() throws TreeManagerException {
	initFennecService();
	return getActiveItem().getNth();
	}

	public int gotoStartOfSiblings() throws TreeManagerException {
	return gotoSiblingIndex(0);
	}

	public int gotoEndOfSiblings() throws TreeManagerException {
	initFennecService();
	ITreeItem[] siblingItems = getSiblings();
	int st = moveUpdate(siblingItems[siblingItems.length - 1], true);
	return st \| ITreeManager.MOVED;
	}

	public int gotoPreviousSibling() throws TreeManagerException {
	int idx = getActiveIndex();
	return gotoSiblingIndex(idx - 1);
	}

	public int gotoNextSibling() throws TreeManagerException {
	int idx = getActiveIndex();
	return gotoSiblingIndex(idx + 1);
	}

	public int gotoStartOfPage() throws TreeManagerException {
	ITreeItem item = getCurrentRootItem();
	int st;
	st = moveUpdate(item, true);
	return ITreeManager.NOACTION;

	/*
	ITreeItem[] childItems = item.getChildItems();
	int st;
	if ((childItems != null) && (childItems.length > 0)) {
	st = moveUpdate(childItems[0], true);
	} else {
	st = moveUpdate(item, true);
	}
	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;*/
	}

	public int gotoEndOfPageForFind() throws TreeManagerException {
	// TODO
	int st;
	this.gotoStartOfPage();
	do {
	st = this.gotoEndOfSiblings();
	} while (this.gotoFirstChild() != ITreeManager.NOACTION);

	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;
	}

	public int gotoEndOfPage() throws TreeManagerException {
	// TODO
	int st;
	this.gotoStartOfPage();
	do {
	st = this.gotoEndOfSiblings();
	} while (this.gotoFirstChild() != ITreeManager.NOACTION);

	ITreeItem item = getActiveItem();
	while (!Vocabulary.hasReadingContent().eval(item)) {
	st = this.traverse(true);
	item = getActiveItem();
	}

	if ((st & ITreeManager.MOVED) != 0)
	st \|= ITreeManager.LEVEL_CHANGED;
	return st;
	}

	public int gotoPreviousLine() throws TreeManagerException {
	// TODO
	return ITreeManager.NOACTION;
	}

	public int gotoNextLine() throws TreeManagerException {
	// TODO
	return ITreeManager.NOACTION;
	}

	public int gotoStartOfLine() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int gotoEndOfLine() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	private int findItem(boolean back, IProposition proposition) throws TreeManagerException {
	try {
	ITreeItem item;
	int[] pos = getActivePos();
	int level = pos.length;
	int rc;
	if (back) {
	// First, traverse to the next item in order to skip the items
	// connectable with the current item.
	rc = traverse(true);
	item = getActiveItem();
	if (proposition.eval(item)) {
	rc \|= ITreeManager.FOUND;
	} else {
	rc = fennecService.searchBackward(proposition);
	}
	} else {
	// Likewise.
	rc = traverse(false);
	item = getActiveItem();
	if (proposition.eval(item)) {
	rc \|= ITreeManager.FOUND;
	} else {
	rc = fennecService.searchForward(proposition);
	}
	}
	if ((rc & ITreeManager.FOUND) == 0) {
	setActivePos(pos);
	return rc;
	}
	item = getActiveItem();
	if (back) {
	// Skip to the interval start.
	ITreeItem siblings[] = getSiblings();
	int idx = item.getNth();
	int st = intervalStart(siblings, idx);
	if (idx != st) {
	rc \|= moveUpdate(siblings[st], false);
	}
	item = getActiveItem();
	}
	if (!Vocabulary.hasReadingContent().eval(item)) {
	traverse(false);
	}
	if (level != getLevel()) {
	rc \|= ITreeManager.LEVEL_CHANGED;
	}
	return rc;
	} catch (FennecInterruptedException e) {
	throw new TreeManagerInterruptedException(ITreeManager.UNDONE, "Failed to search.", e);
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to search.", e);
	}
	}

	private int[] getActivePos() throws TreeManagerException {
	int[] ret = new int[getLevel()];
	ITreeItem current = getActiveItem();
	int count = ret.length;
	while (count > 0) {
	ret[count - 1] = current.getNth();
	count--;
	current = current.getParent();
	}
	return ret;
	}

	private int setActivePos(int[] indexes) throws TreeManagerException {
	gotoRoot();
	ITreeItem item;
	int st = ITreeManager.NOACTION;
	for (int i = 0; i < indexes.length; i++) {
	item = getActiveItem();
	ITreeItem[] children = item.getChildItems();
	int idx = indexes[i];
	if ((children == null) \|\| (idx >= children.length))
	break;
	st \|= moveUpdate(children[idx], true);
	}
	return st;
	}

	public int findNext(IProposition proposition) throws TreeManagerException {
	return findItem(false, proposition);
	}

	public int findPrevious(IProposition proposition) throws TreeManagerException {
	return findItem(true, proposition);
	}

	private int traverseForward(ITreeItem active) throws TreeManagerException {
	ITreeItem[] childItems = active.getChildItems();
	if (childItems.length != 0) {
	int st = moveUpdate(childItems[0], false);
	return st;
	}
	int idx = active.getNth();
	ITreeItem[] siblings = getSiblings();
	if ((idx >= 0) && ((idx + 1) < siblings.length)) {
	int st = moveUpdate(siblings[idx + 1], false);
	return st;
	}

	for (int upCount = 1;; upCount++) {
	active = getActiveItem();
	ITreeItem parent = active.getParent();
	if (parent == null) {
	for (; upCount > 0; upCount--) {
	gotoLastChild();
	}
	return ITreeManager.NOACTION;
	}
	if (moveUpdate(parent, false) == ITreeManager.NOACTION) {
	throw new TreeManagerException(ITreeManager.ERROR, "Internal Error.");
	}
	idx = getActiveIndex();
	siblings = getSiblings();
	if ((idx >= 0) && ((idx + 1) < siblings.length)) {
	int st = moveUpdate(siblings[idx + 1], false);
	return st;
	}
	}
	}

	private int traverseBackward() throws TreeManagerException {
	int idx = getActiveIndex();
	if (idx <= 0) {
	ITreeItem active = getActiveItem();
	ITreeItem parent = active.getParent();
	if (parent == null)
	return ITreeManager.NOACTION;
	int st = moveUpdate(parent, false);
	return st;
	}
	ITreeItem[] siblings = getSiblings();
	int st = moveUpdate(siblings[idx - 1], false);

	for (;;) {
	ITreeItem active = getActiveItem();
	ITreeItem[] childItems = active.getChildItems();
	if (childItems.length == 0)
	break;
	st \|= moveUpdate(childItems[0], false) \| ITreeManager.LEVEL_CHANGED;
	siblings = getSiblings();
	if (siblings.length > 1) {
	st \|= moveUpdate(siblings[siblings.length - 1], false);
	}
	}
	return st;
	}

	private int intervalStart(ITreeItem[] siblings, int st) {
	for (st = st - 1;; st--) {
	if (st < 0)
	return 0;
	if (!Vocabulary.isConnectable().eval(siblings[st]))
	return st + 1;
	}
	}

	private int intervalEnd(ITreeItem[] siblings, int end) {
	for (; end < siblings.length; end++) {
	if (!Vocabulary.isConnectable().eval(siblings[end]))
	return end;
	}
	return end - 1;
	}

	public int traverse(boolean back) throws TreeManagerException {
	initFennecService();
	ITreeItem orig = getActiveItem();
	ITreeItem current = orig;
	int level = getLevel();
	int rc = ITreeManager.NOACTION;

	if (back) {
	do {
	rc = traverseBackward();
	current = getActiveItem();
	} while ((rc != ITreeManager.NOACTION)
	&& (!Vocabulary.hasReadingContent().eval(current)));
	ITreeItem siblings[] = getSiblings();
	int idx = current.getNth();
	int st = intervalStart(siblings, idx);
	if (idx != st) {
	rc \|= moveUpdate(siblings[st], false);
	}
	} else {
	ITreeItem siblings[] = getSiblings();
	int idx = current.getNth();
	int end = intervalEnd(siblings, idx);
	current = siblings[end];
	do {
	rc = traverseForward(current);
	current = getActiveItem();
	} while ((rc != ITreeManager.NOACTION)
	&& (!Vocabulary.hasReadingContent().eval(current)));
	}

	if (!orig.equals(current)) {
	// rc \|= ITreeManager.MOVED;
	if (level != getLevel()) {
	rc \|= ITreeManager.LEVEL_CHANGED;
	}
	}

	return rc;
	}

	public String[] getActiveStrings() throws TreeManagerException {
	initFennecService();
	ArrayList al = new ArrayList();
	ITreeItem[] siblings = getSiblings();
	for (int i = getActiveIndex(); i < siblings.length; i++) {
	ITreeItem current = siblings[i];
	String str = current.getUIString();
	if (str.length() > 0) {
	al.add(str);
	}
	ITreeItem[] childItems = current.getChildItems();
	if (childItems.length > 0)
	break;
	}
	return (String[]) al.toArray(new String[0]);
	}

	public int gotoLeftCell() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int gotoRightCell() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int gotoUpCell() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int gotoDownCell() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int getActiveTableInfo() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public int getActiveTableCellInfo() throws TreeManagerException {
	// TODO Auto-generated method stub
	return 0;
	}

	public ITreeItem getCurrentRootItem() throws TreeManagerException {
	initFennecService();
	ITreeItem parent, current;
	current = getActiveItem();
	while (true) {
	parent = current.getParent();
	if (parent == null)
	break;
	current = parent;
	}
	return current;
	}

	public ISoundControl getSoundControl() throws TreeManagerException {
	initFennecService();
	return fennecService.getSoundControl();
	}

	public IVideoControl getVideoControl() throws TreeManagerException {
	initFennecService();
	return fennecService.getVideoControl();
	}

	public IAccessKeyList getAccessKeyList() throws TreeManagerException {
	initFennecService();
	return fennecService.getAccessKeyList();
	}

	public int analyze() throws TreeManagerException {
	initFennecService();
	try {
	return fennecService.analyze();
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to analyze", e);
	}
	}

	public ILocation getCurrentLocation() throws TreeManagerException {
	initFennecService();
	return new LocationImpl(getActivePos());
	}

	public int moveToLocation(ILocation location) throws TreeManagerException {
	initFennecService();
	LocationImpl loc = (LocationImpl) location;
	int[] pos = loc.getPos();
	return setActivePos(pos);
	}

	public ITreeItem expandWholeTree() throws TreeManagerException {
	initFennecService();
	try {
	return fennecService.expandWholeTree();
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to expand the whole tree", e);
	}
	}

	public int skipToAnchor(String target) throws TreeManagerException {
	initFennecService();
	try {
	return fennecService.skipToAnchor(target);
	} catch (FennecException e) {
	throw new TreeManagerException(ITreeManager.ERROR, "Failed to find the target in the anchors", e);
	}
	}

	public void repairFlash() throws TreeManagerException {
	initFennecService();
	IFlashNode[] node = fennecService.getFlashTopNodes();
	for (int i = 0; i < node.length; i++) {
	node[i].repairFlash();
	}
	}
	}