| /******************************************************************************* |
| * 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: |
| * Daisuke SATO - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.actf.ai.fennec.impl; |
| |
| import java.util.ArrayList; |
| |
| import org.eclipse.actf.ai.fennec.treemanager.ITreeItem; |
| import org.eclipse.actf.model.dom.dombycom.INodeEx; |
| import org.eclipse.actf.util.vocab.DelegationTerms; |
| import org.eclipse.actf.util.vocab.IEvalTarget; |
| import org.eclipse.actf.util.vocab.Vocabulary; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.w3c.dom.Node; |
| |
| |
| |
| |
| public class TreeItemTerms extends DelegationTerms { |
| |
| public TreeItemTerms(IEvalTarget delegationTarget) { |
| super(delegationTarget); |
| } |
| |
| private boolean isSymbol(char c) { |
| int type = Character.getType(c); |
| if (type == Character.OTHER_SYMBOL || type == Character.MODIFIER_SYMBOL || type == Character.MATH_SYMBOL) |
| return true; |
| return false; |
| } |
| |
| private boolean isSeparator(char c) { |
| switch (Character.getType(c)) { |
| case Character.SPACE_SEPARATOR: |
| case Character.LINE_SEPARATOR: |
| case Character.PARAGRAPH_SEPARATOR: |
| case Character.FORMAT: |
| case Character.CONTROL: |
| return true; |
| } |
| return false; |
| } |
| |
| private boolean isPunctuation(char c) { |
| int type = Character.getType(c); |
| if (type == Character.CONNECTOR_PUNCTUATION || type == Character.DASH_PUNCTUATION |
| || type == Character.START_PUNCTUATION || type == Character.END_PUNCTUATION |
| || type == Character.INITIAL_QUOTE_PUNCTUATION || type == Character.FINAL_QUOTE_PUNCTUATION |
| || type == Character.OTHER_PUNCTUATION) |
| return true; |
| return false; |
| } |
| |
| private enum ContentCheckResult { |
| TRUE, FALSE, UNKNOWN |
| } |
| private ContentCheckResult contentCommonCheck(ITreeItem item) { |
| Object baseNode = item.getBaseNode(); |
| if (baseNode instanceof IEvalTarget) { |
| if (Vocabulary.hasContent().eval((IEvalTarget) baseNode)) { |
| return ContentCheckResult.TRUE; |
| } |
| } |
| |
| if (!isVisibleNode(item)) |
| return ContentCheckResult.FALSE; |
| if (Vocabulary.isSelectOption().eval(item)) |
| return ContentCheckResult.FALSE; |
| |
| return ContentCheckResult.UNKNOWN; |
| } |
| |
| @Override |
| public boolean hasContent(IEvalTarget target) { |
| if (!(target instanceof ITreeItem)) |
| return false; |
| ITreeItem item = (ITreeItem) target; |
| switch (contentCommonCheck(item)) { |
| case TRUE: |
| return true; |
| case FALSE: |
| return false; |
| } |
| |
| String str = item.getUIString(); |
| if (str.length() == 0) |
| return false; |
| return true; |
| } |
| |
| @Override |
| public boolean hasReadingContent(IEvalTarget target) { |
| if (!(target instanceof ITreeItem)) |
| return false; |
| ITreeItem item = (ITreeItem) target; |
| switch (contentCommonCheck(item)) { |
| case TRUE: |
| return true; |
| case FALSE: |
| return false; |
| } |
| |
| String str = item.getUIString(); |
| // remove only punctuation |
| if (str.length() == 0) return false; |
| |
| if (Vocabulary.isLink().eval(item)) |
| return true; |
| for (int i = 0; i < str.length(); i++) { |
| if (isSeparator(str.charAt(i)) || isPunctuation(str.charAt(i)) // |
| || isSymbol(str.charAt(i))) |
| continue; |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean isVisibleNode(IEvalTarget target) { |
| return true; |
| } |
| |
| @Override |
| public boolean isBlockJumpPointF(IEvalTarget node) { |
| return isBlockJumpPoint(false, node); |
| } |
| |
| @Override |
| public boolean isBlockJumpPointB(IEvalTarget node) { |
| return isBlockJumpPoint(true, node); |
| } |
| |
| public boolean isBlockJumpPoint(boolean back, IEvalTarget node) { |
| if (!(node instanceof TreeItemFennec)) |
| return false; |
| TreeItemFennec item = (TreeItemFennec) node; |
| |
| TreeItemFennec prev; |
| if (!back) { |
| if (item.getNth() > 0) { |
| prev = (TreeItemFennec) item.getParent().getChildItems()[item.getNth() - 1]; |
| while (prev.hasChild()) { |
| ITreeItem[] items = prev.getChildItems(); |
| prev = (TreeItemFennec) items[items.length - 1]; |
| } |
| } else { |
| prev = (TreeItemFennec) item.getParent(); |
| } |
| } else { |
| if (item.getNth() == item.getParent().getChildItems().length - 1) { |
| ITreeItem parent = item.getParent(); |
| if (parent == null) |
| return false; |
| while (parent.getNth() == parent.getParent().getChildItems().length - 1) { |
| parent = parent.getParent(); |
| if (parent == null) |
| return false; |
| } |
| prev = (TreeItemFennec) parent.getParent().getChildItems()[parent.getNth() + 1]; |
| } else { |
| if (item.hasChild()) { |
| prev = (TreeItemFennec) item.getChildItems()[0]; |
| } else { |
| prev = (TreeItemFennec) item.getParent().getChildItems()[item.getNth() + 1]; |
| } |
| } |
| } |
| if (prev == null) |
| return false; |
| |
| item.distance = prev.distance + 1; |
| prev.distance = 0; |
| |
| if (!(item.getBaseNode() instanceof INodeEx)) |
| return false; |
| if (!(prev.getBaseNode() instanceof INodeEx)) |
| return false; |
| |
| INodeEx nex = (INodeEx) item.getBaseNode(); |
| INodeEx nex2 = (INodeEx) prev.getBaseNode(); |
| if (nex == null || nex2 == null) |
| return false; |
| |
| Rectangle r = nex.getLocation(); |
| Rectangle r2 = nex2.getLocation(); |
| if (r == null || r2 == null) |
| return false; |
| |
| int dist = distance(r, r2); |
| item.distance += dist; |
| |
| if (r.width < 20) |
| return false; |
| if (!Vocabulary.hasContent().eval(node)) |
| return false; |
| if (!Vocabulary.hasReadingContent().eval(node)) |
| return false; |
| if (Vocabulary.isClickable().eval(node)) |
| return false; |
| if (item.getNth() > 2 && Vocabulary.isConnectable().eval(node)) |
| return false; |
| |
| if (item.distance > 800) { |
| item.distance = 0; |
| return true; |
| } |
| |
| if (!back && !super.isBlockJumpPointF(node)) |
| return false; |
| if (back && !super.isBlockJumpPointB(node)) |
| return false; |
| |
| if (item.distance > 200) { |
| item.distance = 0; |
| return true; |
| } |
| return false; |
| } |
| |
| private int distance(Rectangle r, Rectangle r2) { |
| return (int) Math.sqrt(Math.abs(r.x - r2.x) * Math.abs(r.y - r2.y)) // |
| + Math.abs(r.x - r2.x) + Math.abs(r.y - r2.y); |
| } |
| |
| @Override |
| public boolean isHeading(int level, IEvalTarget node) { |
| if (!(node instanceof ITreeItem)) |
| return false; |
| ITreeItem item = (ITreeItem) node; |
| if (level == 0) |
| return (item.getHeadingLevel() > 0); |
| else |
| return item.getHeadingLevel() == level; |
| } |
| |
| @Override |
| public boolean isHeadingJumpPoint(IEvalTarget node) { |
| if (!(node instanceof ITreeItem)) |
| return false; |
| ITreeItem item = (ITreeItem) node; |
| |
| ITreeItem current = item; |
| short r = 0; |
| do { |
| if (current == null) |
| return super.isHeadingJumpPoint(node); |
| FennecMetadata meta = ((TreeItemFennec) current).getMetadata(); |
| if (meta instanceof FennecGeneratedMetadata) { |
| r = ((FennecGeneratedMetadata) meta).getHeadingLevelByMetadata(item); |
| if (r > 0) |
| return true; |
| else if (r == -1) |
| return false; |
| current = current.getParent(); |
| } else |
| break; |
| } while (r == 0); |
| |
| if (((TreeItemFennec) item).getMetadata() == null) |
| return false; |
| return ((TreeItemFennec) item).getMetadata().getHeadingLevel(item) > 0; |
| } |
| |
| @Override |
| public boolean isConnectable(IEvalTarget node) { |
| if (!(node instanceof TreeItemFennec)) |
| return false; |
| TreeItemFennec item = (TreeItemFennec) node; |
| |
| if (item.hasChild()) |
| return false; |
| |
| int nth = item.getNth(); |
| int nextNth = nth + 1; |
| |
| ITreeItem parent = ((TreeItemFennec) node).getParent(); |
| if (parent == null) |
| return false; |
| |
| ITreeItem[] items = parent.getChildItems(); |
| if (nextNth >= items.length) |
| return false; |
| |
| Object o = items[nextNth].getBaseNode(); |
| if (o == null || !(o instanceof Node)) |
| return false; |
| Node n = (Node) o; |
| |
| return Vocabulary.isReachable(n).eval(node); |
| } |
| |
| @Override |
| public boolean find(String str, boolean exact, IEvalTarget node) { |
| if (!(node instanceof ITreeItem)) |
| return false; |
| |
| ITreeItem item = (ITreeItem) node; |
| String uiString = item.getUIString(); |
| |
| if (!exact) { |
| uiString = uiString.toLowerCase(); |
| str = str.toLowerCase(); |
| } |
| |
| if (uiString.indexOf(str) != -1) |
| return true; |
| |
| /* |
| for (int len = str.length() - 1; len > 0; len--) { |
| if (uiString.lastIndexOf(str.substring(0, len)) == uiString.length() - len) { |
| if (hasChild()) { |
| if(Vocabulary.startsWith(str.substring(len), exact).eval(getChildItems()[0])){ |
| return true; |
| } |
| continue; |
| } |
| |
| int nth = item.getNth(); |
| ITreeItem parent = item.getParent(); |
| while (parent != null) { |
| ITreeItem[] items = parent.getChildItems(); |
| if (nth + 1 < items.length) { |
| if(Vocabulary.startsWith(str.substring(len), exact).eval(items[nth + 1])){ |
| return true; |
| } |
| break; |
| } |
| nth = parent.getNth(); |
| parent = parent.getParent(); |
| } |
| } |
| }*/ |
| return false; |
| } |
| |
| @Override |
| public boolean startsWith(String str, boolean exact, IEvalTarget node) { |
| if (!(node instanceof TreeItemFennec)) |
| return false; |
| TreeItemFennec item = (TreeItemFennec) node; |
| String uiString = item.getUIString(); |
| |
| if (!exact) { |
| uiString = uiString.toLowerCase(); |
| str = str.toLowerCase(); |
| } |
| |
| if (uiString.length() < str.length()) { |
| if (str.startsWith(uiString)) { |
| int len = uiString.length(); |
| if (item.hasChild()) { |
| return Vocabulary.startsWith(str.substring(len), exact).eval(item.getChildItems()[0]); |
| } |
| |
| int nth = item.getNth(); |
| ITreeItem parent = item.getParent(); |
| while (parent != null) { |
| ITreeItem[] items = parent.getChildItems(); |
| if (nth + 1 < items.length) { |
| return Vocabulary.startsWith(str.substring(len), exact).eval(items[nth + 1]); |
| } |
| nth = parent.getNth(); |
| parent = parent.getParent(); |
| } |
| } |
| } |
| |
| return uiString.startsWith(str); |
| } |
| |
| @Override |
| public boolean nodeLocation(Node refNode, boolean backward, IEvalTarget node) { |
| if (!Vocabulary.hasContent().eval(node)) |
| return false; |
| if (!(node instanceof TreeItemFennec)) |
| return false; |
| TreeItemFennec item = (TreeItemFennec) node; |
| |
| Node targetNode = item.getNearestNode(); |
| if (targetNode == null) return false; |
| |
| ArrayList<Node> refAncestors = getAncestors(refNode); |
| ArrayList<Node> ancestors = getAncestors(targetNode); |
| int i = refAncestors.size() - 1; |
| int j = ancestors.size() - 1; |
| while ((i >= 0) && (j >= 0)) { |
| Node refAncestor = refAncestors.get(i); |
| Node ancestor = ancestors.get(j); |
| if (!(ancestor.isSameNode(refAncestor))) { |
| if (!((ancestor instanceof INodeEx)) && (refAncestor instanceof INodeEx)) |
| return false; |
| |
| int ancestorNth = ((INodeEx) ancestor).getNth(); |
| int refAncestorNth = ((INodeEx) refAncestor).getNth(); |
| if (ancestorNth == refAncestorNth) |
| return true; |
| if (backward) { |
| return (ancestorNth < refAncestorNth); |
| } else { |
| return (ancestorNth > refAncestorNth); |
| } |
| } |
| i--; |
| j--; |
| } |
| return true; |
| } |
| |
| private ArrayList<Node> getAncestors(Node n) { |
| ArrayList<Node> list = new ArrayList<Node>(); |
| while (n != null) { |
| list.add(n); |
| n = n.getParentNode(); |
| } |
| return list; |
| } |
| } |
