1 /*
2 * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package org.jemmy.swt;
26
27 import java.util.ArrayList;
28 import java.util.LinkedList;
29 import java.util.List;
30 import org.eclipse.swt.widgets.Tree;
31 import org.eclipse.swt.widgets.TreeItem;
32 import org.jemmy.Point;
33 import org.jemmy.action.GetAction;
34 import org.jemmy.control.ControlType;
35 import org.jemmy.control.Property;
36 import org.jemmy.control.Wrap;
37 import org.jemmy.env.Environment;
38 import org.jemmy.input.KeyboardSelectable;
39 import org.jemmy.input.KeyboardSelector;
40 import org.jemmy.input.StringTree;
41 import org.jemmy.interfaces.ControlInterface;
42 import org.jemmy.interfaces.Focusable;
43 import org.jemmy.interfaces.Parent;
44 import org.jemmy.interfaces.Selectable;
45 import org.jemmy.interfaces.Selector;
46 import org.jemmy.interfaces.TypeControlInterface;
47
48 /**
49 *
50 * @author shura
51 * @author erikgreijus
52 */
53 @ControlType(Tree.class)
54 public class TreeWrap<T extends Tree> extends ScrollableWrap<T> implements KeyboardSelectable<String>, Focusable {
55
56 private KeyboardSelector<String> selector = null;
57 private ItemParent<TreeItem> items;
58 private SWTTree tree = null;
59
60 public TreeWrap(Environment env, T node) {
61 super(env, node);
62 }
63
64 private void addItems(TreeItem[] items, LinkedList<TreeItem> list) {
65 for (TreeItem item : items) {
66 list.add(item);
67 if (item.getExpanded()) {
68 addItems(item.getItems(), list);
69 }
70 }
71 }
72
73 public List<TreeItem> getItems() {
74 return new GetAction<List<TreeItem>>() {
75
76 @Override
77 public void run(Object... parameters) throws Exception {
78 LinkedList<TreeItem> res = new LinkedList<>();
79 addItems(getControl().getItems(), res);
80 setResult(res);
81 }
82 }.dispatch(getEnvironment());
83 }
84
85 public TreeItem getSelectedItem() {
86 return new GetAction<TreeItem>() {
87
88 @Override
89 public void run(Object... parameters) throws Exception {
90 if (getControl().getSelection().length > 0) {
91 setResult(getControl().getSelection()[0]);
92 } else {
93 setResult(null);
94 }
95 }
96 }.dispatch(getEnvironment());
97 }
98
99 @Override
100 public int selection() {
101 return new GetAction<Integer>() {
102
103 @Override
104 public void run(Object... parameters) throws Exception {
105 if (getControl().getSelection().length > 0) {
106 TreeItem selection = getControl().getSelection()[0];
107 setResult(0);
108 if (selection != null) {
109 List<TreeItem> items = getItems();
110 for (int i = 0; i < items.size(); i++) {
111 if (items.get(i) == selection) {
112 setResult(i);
113 }
114 }
115 }
116 } else {
117 setResult(0);
118 }
119
120 }
121 }.dispatch(getEnvironment());
122 }
123
124 @Override
125 public boolean isVertical() {
126 return true;
127 }
128
129 public int index(TreeItem item) {
130 return getItems().indexOf(item);
131 }
132
133 @Override
134 public Selector<String> selector() {
135 if (selector == null) {
136 selector = new KeyboardSelector<>(this, this);
137 }
138 return selector;
139 }
140
141 @Override
142 public Class<String> getType() {
143 return String.class;
144 }
145
146 /**
147 * Click point for Tree (top of the visible part)
148 *
149 * @return The click point of this Tree
150 */
151 @Override
152 @Property(Wrap.CLICKPOINT_PROP_NAME)
153 public Point getClickPoint() {
154 return new Point(getScreenBounds().getWidth() / 2, 1);
155 }
156
157 @Override
158 public <TYPE, INTERFACE extends TypeControlInterface<TYPE>> INTERFACE as(Class<INTERFACE> interfaceClass, Class<TYPE> type) {
159 if (interfaceClass.equals(Parent.class) && TreeItem.class.equals(type)) {
160 if (items == null) {
161 items = new ItemParent<TreeItem>(this, TreeItem.class) {
162
163 @Override
164 protected List<TreeItem> getItems() {
165 return TreeWrap.this.getItems();
166 }
167 };
168 }
169 return (INTERFACE) items;
170 }
171 if (org.jemmy.interfaces.Tree.class.isAssignableFrom(interfaceClass)
172 && interfaceClass.isAssignableFrom(StringTree.class) && TreeItem.class.equals(type)) {
173 if (tree == null) {
174 tree = new SWTTree(this);
175 }
176 return (INTERFACE) tree;
177 }
178 return super.as(interfaceClass, type);
179 }
180
181 @Override
182 public <INTERFACE extends ControlInterface> INTERFACE as(Class<INTERFACE> interfaceClass) {
183 if (org.jemmy.interfaces.Tree.class.isAssignableFrom(interfaceClass)
184 && interfaceClass.isAssignableFrom(StringTree.class)) {
185 if (tree == null) {
186 tree = new SWTTree(this);
187 }
188 return (INTERFACE) tree;
189 }
190 return super.as(interfaceClass);
191 }
192
193 @Override
194 public <TYPE, INTERFACE extends TypeControlInterface<TYPE>> boolean is(Class<INTERFACE> interfaceClass, Class<TYPE> type) {
195 if (interfaceClass.equals(Parent.class) && TreeItem.class.equals(type)) {
196 return true;
197 }
198 if (org.jemmy.interfaces.Tree.class.isAssignableFrom(interfaceClass)
199 && interfaceClass.isAssignableFrom(StringTree.class) && TreeItem.class.equals(type)) {
200 return true;
201 }
202 return super.is(interfaceClass, type);
203 }
204
205 @Override
206 public <INTERFACE extends ControlInterface> boolean is(Class<INTERFACE> interfaceClass) {
207 if (org.jemmy.interfaces.Tree.class.isAssignableFrom(interfaceClass)
208 && interfaceClass.isAssignableFrom(StringTree.class)) {
209 return true;
210 }
211 return super.is(interfaceClass);
212 }
213
214 @Override
215 public int index(String item) {
216 return getStates().indexOf(item);
217 }
218
219 @Property(Selectable.STATES_PROP_NAME)
220 @Override
221 public List<String> getStates() {
222 return new GetAction<List<String>>() {
223
224 @Override
225 public void run(Object... parameters) throws Exception {
226 List<TreeItem> itms = getItems();
227 List<String> res = new ArrayList<>(itms.size());
228 itms.stream().forEach((i) -> {
229 res.add(i.getText());
230 });
231 setResult(res);
232 }
233 }.dispatch(getEnvironment());
234 }
235
236 @Property(Selectable.STATE_PROP_NAME)
237 @Override
238 public String getState() {
239 return new GetAction<String>() {
240
241 @Override
242 public void run(Object... parameters) throws Exception {
243 setResult((getSelectedItem() == null) ? "" : getSelectedItem().getText());
244 }
245 }.dispatch(getEnvironment());
246 }
247 }