| /******************************************************************************* |
| * 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.util.vocab; |
| |
| import org.w3c.dom.Node; |
| |
| |
| |
| /** |
| * This class delegates the evaluation to the delegation target. |
| */ |
| public class DelegationTerms extends AbstractTerms { |
| |
| private final IEvalTarget delegationTarget; |
| |
| //private AbstractTerms nextCandidate; |
| |
| /** |
| * @param delegationTarget the delegation target. |
| */ |
| public DelegationTerms(IEvalTarget delegationTarget) { |
| this.delegationTarget = delegationTarget; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isClickable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isClickable(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isClickable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isEditable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isEditable(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isEditable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#hasContent(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean hasContent(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().hasContent(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#hasReadingContent(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean hasReadingContent(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().hasReadingContent(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isEnabled(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isEnabled(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isEnabled(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isInputable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isInputable(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isInputable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isSelectable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isSelectable(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isSelectable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isMultiSelectable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isMultiSelectable(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isMultiSelectable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isButton(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isButton(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isButton(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isListItem(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isListItem(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isListItem(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isListTop(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isListTop(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isListTop(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isCheckbox(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isCheckbox(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isCheckbox(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isChecked(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isChecked(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isChecked(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isLabel(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isLabel(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isLabel(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isLink(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isLink(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isLink(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isVisitedLink(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isVisitedLink(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isVisitedLink(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isRadio(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isRadio(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isRadio(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isCombobox(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isCombobox(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isCombobox(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isSubmit(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isSubmit(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isSubmit(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isFileEdit(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isFileEdit(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isFileEdit(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isTextarea(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isTextarea(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isTextarea(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isTextbox(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isTextbox(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isTextbox(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isPassword(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isPassword(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isPassword(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isValidNode(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isValidNode(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isValidNode(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isVisibleNode(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isVisibleNode(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isVisibleNode(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isEmbeddedObject(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isEmbeddedObject(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isEmbeddedObject(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isImage(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isImage(IEvalTarget target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isImage(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isMultilineEdit(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isMultilineEdit(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isMultilineEdit(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isSelectOption(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isSelectOption(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isSelectOption(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isReducible(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isReducible(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isReducible(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isConnectable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isConnectable(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isConnectable(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#find(java.lang.String, boolean, org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean find(String str, boolean exact, IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().find(str, exact, delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#startsWith(java.lang.String, boolean, org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean startsWith(String str, boolean exact, IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().startsWith(str, exact, delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isHeading(int, org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isHeading(int level, IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isHeading(level, delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isHeadingJumpPoint(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isHeadingJumpPoint(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isHeadingJumpPoint(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#nodeLocation(org.w3c.dom.Node, boolean, org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean nodeLocation(Node refNode, boolean backward, IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().nodeLocation(refNode, backward, delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isAccessKey(char, org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isAccessKey(char key, IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isAccessKey(key, delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isListItemJumpPoint(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isListItemJumpPoint(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isListItemJumpPoint(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isBlockJumpPointF(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isBlockJumpPointF(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isBlockJumpPointF(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isBlockJumpPointB(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isBlockJumpPointB(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isBlockJumpPointB(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isMedia(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isMedia(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isMedia(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isFlashTopNode(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isFlashTopNode(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isFlashTopNode(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isFlashLastNode(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isFlashLastNode(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isFlashLastNode(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isMSAAFlash(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isMSAAFlash(IEvalTarget node) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isMSAAFlash(delegationTarget); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isReachable(org.eclipse.actf.util.vocab.IEvalTarget, org.w3c.dom.Node) |
| */ |
| @Override |
| public boolean isReachable(IEvalTarget node, Node target) { |
| if (delegationTarget == null) |
| return false; |
| return delegationTarget.getTerms().isReachable(delegationTarget, target); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.actf.util.vocab.AbstractTerms#isAlterable(org.eclipse.actf.util.vocab.IEvalTarget) |
| */ |
| @Override |
| public boolean isAlterable(IEvalTarget node) { |
| if (delegationTarget == null) return false; |
| return delegationTarget.getTerms().isAlterable(delegationTarget); |
| } |
| |
| } |
