clover

Clover coverage report - clover

Coverage timestamp: Sat Oct 8 2005 22:54:17 EDT

FRAMES NO FRAMES

file stats:	LOC:	709		Methods:	54
	NCLOC:	562		Classes:	4

Source file

Conditionals

Statements

Methods

TOTAL

ComponentBrowser.java

34.4%

65.8%

59.3%

58.3%

 package abbot.editor;
 
 import java.awt.*;
 import java.awt.event.*;
 import java.lang.reflect.Method;
 import java.util.*;
 
 import javax.swing.*;
 import javax.swing.border.*;
 import javax.swing.event.*;
 import javax.swing.tree.*;
 import javax.swing.table.*;
 
 import abbot.*;
 import abbot.editor.editors.XMLEditor;
 import abbot.editor.widgets.*;
 import abbot.finder.*;
 import abbot.i18n.Strings;
 import abbot.script.*;
 import abbot.script.Resolver;
 import abbot.tester.Robot;
 import abbot.util.*;
 
 /** Browse an existing component hierarchy.  Thanks to the JFCUnit guys for
  * the basis for this code.
  */
 // FIXME put the component reference ID into a label, not in the status
 public class ComponentBrowser
     extends JPanel implements ActionListener {
     private int TAB_HIERARCHY = 0;
 
     private JButton refreshButton;
     private JCheckBox filterButton;
     private JButton addAssertButton;
     private JButton addSampleButton;
     private JCheckBox filterPropertiesCheckBox;
     private Resolver resolver;
     private ComponentTree componentTree;
     private JTable propTable;
     private ReferencesModel refModel;
     private JTable refTable;
     private ComponentPropertyModel propertyModel;
     private JTable attributeTable;
     private ReferenceAttributeModel attributeModel;
     private JTable inputMapTable;
     private JTable actionMapTable;
 
     private boolean filter = true;
 
     private JTabbedPane tabs;
     private JTabbedPane tabs2;
 
     /** Currently selected component. */
     private Component selectedComponent = null;
     /** Is the currently selected component "fake"? */
     private boolean fakeComponent = false;
     /** Currently selected reference. */
     private ComponentReference selectedReference = null;
     private LocalHierarchy hierarchy;
 
     /**
      * Default constructor
      */
     public ComponentBrowser(Resolver r, Hierarchy h) {
         this.resolver = r;
         this.hierarchy = new LocalHierarchy(h);
         setName("browser");
         equip(this);
         setSelectedComponent(null);
         setSelectedReference(null);
     }
 
     /**
      * Method to create required widgets/components and populate
      * the content pane with them.
      *
      * @param pane   The content pane to which the created objects have to
      *               be added into.
      */
     private void equip(Container pane) {
         setLayout(new BorderLayout());
         JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
                                           createLeftPanel(),
                                           createRightPanel());
         // prefer tree over property table
         split.setResizeWeight(1.0);
         split.setDividerSize(4);
         split.setBorder(null);
         pane.add(split, BorderLayout.CENTER);
     }
 
     private JPanel createHierarchyView() {
         JPanel pane = new JPanel(new BorderLayout());
         componentTree = new ComponentTree(hierarchy);
         componentTree.setName("browser.hierarchy");
         componentTree.addTreeSelectionListener(new TreeSelectionListener(){
             public void valueChanged(TreeSelectionEvent e) {
                 if (!ignoreHierarchyChange) {
                     setSelectedComponent(getSelectedComponentFromTree());
                 }
             }
         });
         JScrollPane scroll = new JScrollPane(componentTree);
         scroll.getViewport().setBackground(componentTree.getBackground());
         pane.add(scroll, BorderLayout.CENTER);
 
         refreshButton = new JButton(Strings.get("browser.hierarchy.reload"));
         refreshButton.addActionListener(this);
         filterButton = new JCheckBox(Strings.get("browser.hierarchy.concise"));
         filterButton.addActionListener(this);
         filterButton.setSelected(filter);
         filterButton.setToolTipText(Strings.get("browser.hierarchy.filter.tip"));
         JPanel buttons = new JPanel();
         buttons.setBorder(new EmptyBorder(0, 0, 0, 0));
         buttons.add(refreshButton);
         buttons.add(filterButton);
         JPanel leftJustify = new JPanel(new BorderLayout());
         leftJustify.setBorder(new EmptyBorder(0, 0, 0, 0));
         leftJustify.add(buttons, BorderLayout.WEST);
         pane.add(leftJustify, BorderLayout.SOUTH);
         return pane;
     }
 
     /** Set the resolver on which the references list is based. */
     public void setResolver(Resolver resolver) {
         this.resolver = resolver;
         refModel = new ReferencesModel(resolver);
         refTable.setModel(refModel);
     }
 
     private Component createReferenceView() {
         // FIXME need buttons for new/delete (delete only enabled if the
         // reference is entirely unused
         refModel = new ReferencesModel(resolver);
         refTable = new JTable(refModel) {
             public void setRowSelectionInterval(int start, int end) {
                 super.setRowSelectionInterval(start, end);
                 // Make sure the selection is always visible. 
                 Rectangle cellRect = getCellRect(start, 0, true);
                 if (cellRect != null)
                     super.scrollRectToVisible(cellRect);
             }
         };
         refTable.setName("browser.references");
         refTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
         refTable.setDefaultEditor(ComponentReference.class, new XMLEditor());
         refTable.clearSelection();
         ListSelectionListener lsl = new ListSelectionListener() {
             public void valueChanged(ListSelectionEvent lse) {
                 if (!lse.getValueIsAdjusting()) {
                     referenceListSelectionChanged(lse);
                 }
             }
         };
         refTable.getSelectionModel().addListSelectionListener(lsl);
         JScrollPane scroll = new JScrollPane(refTable);
         scroll.getViewport().setBackground(refTable.getBackground());
         return scroll;
     }
 
     /**
      * Create a tabbed pane for browsing either existing components or
      * component references.
      *
      * @return A JPanel for the left side of the main frame
      */
     private Component createLeftPanel() {
         tabs = new JTabbedPane() {
             public Dimension getPreferredSize() {
                 return new Dimension(250, 200);
             }
         };
         tabs.add(Strings.get("Hierarchy"), createHierarchyView());
         tabs.setToolTipTextAt(0, Strings.get("browser.hierarchy.tip"));
         tabs.add(Strings.get("References"), createReferenceView());
         tabs.setToolTipTextAt(1, Strings.get("browser.references.tip"));
         tabs.addChangeListener(new ChangeListener() {
             public void stateChanged(ChangeEvent e) {
                 tabChanged(e);
             }
         });
         return tabs;
     }
 
     /**
      * Create the property browser/selection table.
      *
      * @return A JPanel for the right side of the main frame
      */
     private Component createRightPanel() {
         JPanel pane = new JPanel(new BorderLayout());
         propertyModel = new ComponentPropertyModel();
         propTable = new JTable(propertyModel);
         propTable.setName("browser.properties");
         propTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
         propTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
         propTable.setDefaultRenderer(Object.class, new PropertyRenderer());
         ListSelectionListener lsl = new ListSelectionListener() {
             public void valueChanged(ListSelectionEvent lse) {
                 if (!lse.getValueIsAdjusting()) {
                     enableAssertSampleButtons();
                 }
             }
         };
         propTable.getSelectionModel().addListSelectionListener(lsl);
 
         addAssertButton = new JButton("");
         addAssertButton.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent ev) {
                 firePropertyCheck(false);
             }
         });
         addAssertButton.setEnabled(false);
         updateAssertText(false, false);
 
         addSampleButton = new JButton(Strings.get("SampleProperty"));
         addSampleButton.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent ev) {
                 firePropertyCheck(true);
             }
         });
         addSampleButton.setEnabled(false);
 
         String waitKeyName = KeyEvent.getKeyText(ScriptEditor.KC_WAIT);
         String invertKeyName = KeyEvent.getKeyText(ScriptEditor.KC_INVERT);
         String tip = Strings.get("AssertPropertyTip",
                                  new Object[] {
                                      invertKeyName, waitKeyName,
                                  });
         addAssertButton.setToolTipText(TextFormat.tooltip(tip));
         tip = Strings.get("SamplePropertyTip");
         addSampleButton.setToolTipText(TextFormat.tooltip(tip));
 
         filterPropertiesCheckBox = new JCheckBox(Strings.get("Filter"));
         filterPropertiesCheckBox.addActionListener(this);
         filterPropertiesCheckBox.setEnabled(true);
         filterPropertiesCheckBox.setSelected(true); 
         filterPropertiesCheckBox.setToolTipText(Strings.get("browser.properties.filter.tip"));
         JPanel buttonsPanel = new JPanel();
         buttonsPanel.add(addAssertButton);
         buttonsPanel.add(addSampleButton);
         buttonsPanel.add(filterPropertiesCheckBox);
         JPanel leftJustify = new JPanel(new BorderLayout());
         leftJustify.setBorder(new EmptyBorder(0, 0, 0, 0));
         leftJustify.add(buttonsPanel, BorderLayout.WEST);
 
         JScrollPane scroll = new JScrollPane(propTable);
         scroll.getViewport().setBackground(propTable.getBackground());
         scroll.setColumnHeaderView(propTable.getTableHeader());
         pane.add(scroll, BorderLayout.CENTER);
         pane.add(leftJustify, BorderLayout.SOUTH);
 
         attributeModel = new ReferenceAttributeModel();
         attributeModel.addTableModelListener(new AttributeListener());
         attributeTable = new JTable(attributeModel);
         JScrollPane scroll1 = new JScrollPane(attributeTable);
         scroll1.getViewport().setBackground(attributeTable.getBackground());
 
         inputMapTable = new JTable(InputMapModel.EMPTY);
         JScrollPane scroll2 = new JScrollPane(inputMapTable);
         scroll2.getViewport().setBackground(inputMapTable.getBackground());
 
         actionMapTable = new JTable(ActionMapModel.EMPTY);
         JScrollPane scroll3 = new JScrollPane(actionMapTable);
         scroll3.getViewport().setBackground(actionMapTable.getBackground());
 
         tabs2 = new JTabbedPane() {
             public Dimension getPreferredSize() {
                 return new Dimension(300, 150);
             }
         };
         tabs2.add(Strings.get("browser.properties"), pane);
         tabs2.setToolTipTextAt(0, Strings.get("browser.properties.tip"));
         tabs2.add(Strings.get("browser.attributes"), scroll1);
         tabs2.setToolTipTextAt(1, Strings.get("browser.attributes.tip"));
         tabs2.add(Strings.get("browser.inputmap"), scroll2);
         tabs2.setToolTipTextAt(2, Strings.get("browser.inputmap.tip"));
         tabs2.add(Strings.get("browser.actionmap"), scroll3);
         tabs2.setToolTipTextAt(3, Strings.get("browser.actionmap.tip"));
 
         return tabs2;
     }
 
     public void updateAssertText(boolean isWait, boolean invert) {
         addAssertButton.setText(Strings.get(isWait ? "WaitProperty"
                                             : "AssertProperty",
                                             new Object[]{ 
                                                 invert
                                                 ? Strings.get("assert.not_equals")
                                                 : Strings.get("assert.equals")
                                             }));
     }
 
     /** Select the given reference in the current view. */
     public void setSelectedReference(ComponentReference ref) {
         if (ref != selectedReference) {
             selectedReference = ref;
             updateReferenceSelection(ref);
             Component c = ref != null
                 ? getComponentForReference(ref) : null;
             if (c != selectedComponent) {
                 selectedComponent = c;
                 updateComponentSelection(c);
             }
             fireSelectionChanged();
         }
     }
 
     /** Select the given component (and make it visible) in the current
         view.  Update the auxiliary view components appropriately.
         If showing component references and the given component doesn't have
         one, switch the view to the hierarchy.
     */ 
     public void setSelectedComponent(Component comp) {
         selectedComponent = comp;
         ComponentReference ref = null;
         if (comp != null && resolver.getHierarchy().contains(comp)) {
             ref = resolver.getComponentReference(comp);
         }
         if (ref != selectedReference) {
             selectedReference = ref;
             updateReferenceSelection(ref);
         }
         if (ref == null && !showingHierarchy()) {
             tabs.setSelectedIndex(TAB_HIERARCHY);
         }
         updateComponentSelection(comp);
         fireSelectionChanged();
     }
 
     /** Return the row index of the given component reference. */
     private int getRow(ComponentReference ref) {
         if (ref != null) {
             for (int i=0;i < refTable.getRowCount();i++) {
                 ComponentReference value = (ComponentReference)
                     refTable.getValueAt(i, 0);
                 if (ref == value) {
                     return i;
                 }
             }
         }
         return -1;
     }
 
     /** Flag to avoid responding to list/tree selection changes when they're
      * made programmatically instead of by the user.
      */
     private boolean ignoreHierarchyChange = false;
     private boolean ignoreReferenceChange = false;
 
     /** Set the appropriate selection in the reference list. */
     private void updateReferenceSelection(ComponentReference ref) {
         if (!showingHierarchy()) {
             int row = getRow(ref);
             ignoreReferenceChange = true;
             if (row == -1) {
                 refTable.clearSelection();
             }
             else {
                 refTable.setRowSelectionInterval(row, row);
             }
             ignoreReferenceChange = false;
         }
         updateAttributesList();
         updatePropertyList();
     }
 
     /** Set the appropriate selection in the component hierarchy tree. */
     private void updateComponentSelection(Component comp) {
         if (showingHierarchy()) {
             ignoreHierarchyChange = true;


1		package abbot.editor;
2
3		import java.awt.*;
4		import java.awt.event.*;
5		import java.lang.reflect.Method;
6		import java.util.*;
7
8		import javax.swing.*;
9		import javax.swing.border.*;
10		import javax.swing.event.*;
11		import javax.swing.tree.*;
12		import javax.swing.table.*;
13
14		import abbot.*;
15		import abbot.editor.editors.XMLEditor;
16		import abbot.editor.widgets.*;
17		import abbot.finder.*;
18		import abbot.i18n.Strings;
19		import abbot.script.*;
20		import abbot.script.Resolver;
21		import abbot.tester.Robot;
22		import abbot.util.*;
23
24		/** Browse an existing component hierarchy. Thanks to the JFCUnit guys for
25		* the basis for this code.
26		*/
27		// FIXME put the component reference ID into a label, not in the status
28		public class ComponentBrowser
29		extends JPanel implements ActionListener {
30		private int TAB_HIERARCHY = 0;
31
32		private JButton refreshButton;
33		private JCheckBox filterButton;
34		private JButton addAssertButton;
35		private JButton addSampleButton;
36		private JCheckBox filterPropertiesCheckBox;
37		private Resolver resolver;
38		private ComponentTree componentTree;
39		private JTable propTable;
40		private ReferencesModel refModel;
41		private JTable refTable;
42		private ComponentPropertyModel propertyModel;
43		private JTable attributeTable;
44		private ReferenceAttributeModel attributeModel;
45		private JTable inputMapTable;
46		private JTable actionMapTable;
47
48		private boolean filter = true;
49
50		private JTabbedPane tabs;
51		private JTabbedPane tabs2;
52
53		/** Currently selected component. */
54		private Component selectedComponent = null;
55		/** Is the currently selected component "fake"? */
56		private boolean fakeComponent = false;
57		/** Currently selected reference. */
58		private ComponentReference selectedReference = null;
59		private LocalHierarchy hierarchy;
60
61		/**
62		* Default constructor
63		*/
64	4	public ComponentBrowser(Resolver r, Hierarchy h) {
65	4	this.resolver = r;
66	4	this.hierarchy = new LocalHierarchy(h);
67	4	setName("browser");
68	4	equip(this);
69	4	setSelectedComponent(null);
70	4	setSelectedReference(null);
71		}
72
73		/**
74		* Method to create required widgets/components and populate
75		* the content pane with them.
76		*
77		* @param pane The content pane to which the created objects have to
78		* be added into.
79		*/
80	4	private void equip(Container pane) {
81	4	setLayout(new BorderLayout());
82	4	JSplitPane split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
83		createLeftPanel(),
84		createRightPanel());
85		// prefer tree over property table
86	4	split.setResizeWeight(1.0);
87	4	split.setDividerSize(4);
88	4	split.setBorder(null);
89	4	pane.add(split, BorderLayout.CENTER);
90		}
91
92	4	private JPanel createHierarchyView() {
93	4	JPanel pane = new JPanel(new BorderLayout());
94	4	componentTree = new ComponentTree(hierarchy);
95	4	componentTree.setName("browser.hierarchy");
96	4	componentTree.addTreeSelectionListener(new TreeSelectionListener(){
97	4	public void valueChanged(TreeSelectionEvent e) {
98	4	if (!ignoreHierarchyChange) {
99	1	setSelectedComponent(getSelectedComponentFromTree());
100		}
101		}
102		});
103	4	JScrollPane scroll = new JScrollPane(componentTree);
104	4	scroll.getViewport().setBackground(componentTree.getBackground());
105	4	pane.add(scroll, BorderLayout.CENTER);
106
107	4	refreshButton = new JButton(Strings.get("browser.hierarchy.reload"));
108	4	refreshButton.addActionListener(this);
109	4	filterButton = new JCheckBox(Strings.get("browser.hierarchy.concise"));
110	4	filterButton.addActionListener(this);
111	4	filterButton.setSelected(filter);
112	4	filterButton.setToolTipText(Strings.get("browser.hierarchy.filter.tip"));
113	4	JPanel buttons = new JPanel();
114	4	buttons.setBorder(new EmptyBorder(0, 0, 0, 0));
115	4	buttons.add(refreshButton);
116	4	buttons.add(filterButton);
117	4	JPanel leftJustify = new JPanel(new BorderLayout());
118	4	leftJustify.setBorder(new EmptyBorder(0, 0, 0, 0));
119	4	leftJustify.add(buttons, BorderLayout.WEST);
120	4	pane.add(leftJustify, BorderLayout.SOUTH);
121	4	return pane;
122		}
123
124		/** Set the resolver on which the references list is based. */
125	8	public void setResolver(Resolver resolver) {
126	8	this.resolver = resolver;
127	8	refModel = new ReferencesModel(resolver);
128	8	refTable.setModel(refModel);
129		}
130
131	4	private Component createReferenceView() {
132		// FIXME need buttons for new/delete (delete only enabled if the
133		// reference is entirely unused
134	4	refModel = new ReferencesModel(resolver);
135	4	refTable = new JTable(refModel) {
136	0	public void setRowSelectionInterval(int start, int end) {
137	0	super.setRowSelectionInterval(start, end);
138		// Make sure the selection is always visible.
139	0	Rectangle cellRect = getCellRect(start, 0, true);
140	0	if (cellRect != null)
141	0	super.scrollRectToVisible(cellRect);
142		}
143		};
144	4	refTable.setName("browser.references");
145	4	refTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
146	4	refTable.setDefaultEditor(ComponentReference.class, new XMLEditor());
147	4	refTable.clearSelection();
148	4	ListSelectionListener lsl = new ListSelectionListener() {
149	0	public void valueChanged(ListSelectionEvent lse) {
150	0	if (!lse.getValueIsAdjusting()) {
151	0	referenceListSelectionChanged(lse);
152		}
153		}
154		};
155	4	refTable.getSelectionModel().addListSelectionListener(lsl);
156	4	JScrollPane scroll = new JScrollPane(refTable);
157	4	scroll.getViewport().setBackground(refTable.getBackground());
158	4	return scroll;
159		}
160
161		/**
162		* Create a tabbed pane for browsing either existing components or
163		* component references.
164		*
165		* @return A JPanel for the left side of the main frame
166		*/
167	4	private Component createLeftPanel() {
168	4	tabs = new JTabbedPane() {
169	2	public Dimension getPreferredSize() {
170	2	return new Dimension(250, 200);
171		}
172		};
173	4	tabs.add(Strings.get("Hierarchy"), createHierarchyView());
174	4	tabs.setToolTipTextAt(0, Strings.get("browser.hierarchy.tip"));
175	4	tabs.add(Strings.get("References"), createReferenceView());
176	4	tabs.setToolTipTextAt(1, Strings.get("browser.references.tip"));
177	4	tabs.addChangeListener(new ChangeListener() {
178	0	public void stateChanged(ChangeEvent e) {
179	0	tabChanged(e);
180		}
181		});
182	4	return tabs;
183		}
184
185		/**
186		* Create the property browser/selection table.
187		*
188		* @return A JPanel for the right side of the main frame
189		*/
190	4	private Component createRightPanel() {
191	4	JPanel pane = new JPanel(new BorderLayout());
192	4	propertyModel = new ComponentPropertyModel();
193	4	propTable = new JTable(propertyModel);
194	4	propTable.setName("browser.properties");
195	4	propTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
196	4	propTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
197	4	propTable.setDefaultRenderer(Object.class, new PropertyRenderer());
198	4	ListSelectionListener lsl = new ListSelectionListener() {
199	0	public void valueChanged(ListSelectionEvent lse) {
200	0	if (!lse.getValueIsAdjusting()) {
201	0	enableAssertSampleButtons();
202		}
203		}
204		};
205	4	propTable.getSelectionModel().addListSelectionListener(lsl);
206
207	4	addAssertButton = new JButton("");
208	4	addAssertButton.addActionListener(new ActionListener() {
209	0	public void actionPerformed(ActionEvent ev) {
210	0	firePropertyCheck(false);
211		}
212		});
213	4	addAssertButton.setEnabled(false);
214	4	updateAssertText(false, false);
215
216	4	addSampleButton = new JButton(Strings.get("SampleProperty"));
217	4	addSampleButton.addActionListener(new ActionListener() {
218	0	public void actionPerformed(ActionEvent ev) {
219	0	firePropertyCheck(true);
220		}
221		});
222	4	addSampleButton.setEnabled(false);
223
224	4	String waitKeyName = KeyEvent.getKeyText(ScriptEditor.KC_WAIT);
225	4	String invertKeyName = KeyEvent.getKeyText(ScriptEditor.KC_INVERT);
226	4	String tip = Strings.get("AssertPropertyTip",
227		new Object[] {
228		invertKeyName, waitKeyName,
229		});
230	4	addAssertButton.setToolTipText(TextFormat.tooltip(tip));
231	4	tip = Strings.get("SamplePropertyTip");
232	4	addSampleButton.setToolTipText(TextFormat.tooltip(tip));
233
234	4	filterPropertiesCheckBox = new JCheckBox(Strings.get("Filter"));
235	4	filterPropertiesCheckBox.addActionListener(this);
236	4	filterPropertiesCheckBox.setEnabled(true);
237	4	filterPropertiesCheckBox.setSelected(true);
238	4	filterPropertiesCheckBox.setToolTipText(Strings.get("browser.properties.filter.tip"));
239	4	JPanel buttonsPanel = new JPanel();
240	4	buttonsPanel.add(addAssertButton);
241	4	buttonsPanel.add(addSampleButton);
242	4	buttonsPanel.add(filterPropertiesCheckBox);
243	4	JPanel leftJustify = new JPanel(new BorderLayout());
244	4	leftJustify.setBorder(new EmptyBorder(0, 0, 0, 0));
245	4	leftJustify.add(buttonsPanel, BorderLayout.WEST);
246
247	4	JScrollPane scroll = new JScrollPane(propTable);
248	4	scroll.getViewport().setBackground(propTable.getBackground());
249	4	scroll.setColumnHeaderView(propTable.getTableHeader());
250	4	pane.add(scroll, BorderLayout.CENTER);
251	4	pane.add(leftJustify, BorderLayout.SOUTH);
252
253	4	attributeModel = new ReferenceAttributeModel();
254	4	attributeModel.addTableModelListener(new AttributeListener());
255	4	attributeTable = new JTable(attributeModel);
256	4	JScrollPane scroll1 = new JScrollPane(attributeTable);
257	4	scroll1.getViewport().setBackground(attributeTable.getBackground());
258
259	4	inputMapTable = new JTable(InputMapModel.EMPTY);
260	4	JScrollPane scroll2 = new JScrollPane(inputMapTable);
261	4	scroll2.getViewport().setBackground(inputMapTable.getBackground());
262
263	4	actionMapTable = new JTable(ActionMapModel.EMPTY);
264	4	JScrollPane scroll3 = new JScrollPane(actionMapTable);
265	4	scroll3.getViewport().setBackground(actionMapTable.getBackground());
266
267	4	tabs2 = new JTabbedPane() {
268	2	public Dimension getPreferredSize() {
269	2	return new Dimension(300, 150);
270		}
271		};
272	4	tabs2.add(Strings.get("browser.properties"), pane);
273	4	tabs2.setToolTipTextAt(0, Strings.get("browser.properties.tip"));
274	4	tabs2.add(Strings.get("browser.attributes"), scroll1);
275	4	tabs2.setToolTipTextAt(1, Strings.get("browser.attributes.tip"));
276	4	tabs2.add(Strings.get("browser.inputmap"), scroll2);
277	4	tabs2.setToolTipTextAt(2, Strings.get("browser.inputmap.tip"));
278	4	tabs2.add(Strings.get("browser.actionmap"), scroll3);
279	4	tabs2.setToolTipTextAt(3, Strings.get("browser.actionmap.tip"));
280
281	4	return tabs2;
282		}
283
284	4	public void updateAssertText(boolean isWait, boolean invert) {
285	4	addAssertButton.setText(Strings.get(isWait ? "WaitProperty"
286		: "AssertProperty",
287		new Object[]{
288	4	invert
289		? Strings.get("assert.not_equals")
290		: Strings.get("assert.equals")
291		}));
292		}
293
294		/** Select the given reference in the current view. */
295	11	public void setSelectedReference(ComponentReference ref) {
296	11	if (ref != selectedReference) {
297	0	selectedReference = ref;
298	0	updateReferenceSelection(ref);
299	0	Component c = ref != null
300		? getComponentForReference(ref) : null;
301	0	if (c != selectedComponent) {
302	0	selectedComponent = c;
303	0	updateComponentSelection(c);
304		}
305	0	fireSelectionChanged();
306		}
307		}
308
309		/** Select the given component (and make it visible) in the current
310		view. Update the auxiliary view components appropriately.
311		If showing component references and the given component doesn't have
312		one, switch the view to the hierarchy.
313		*/
314	7	public void setSelectedComponent(Component comp) {
315	7	selectedComponent = comp;
316	7	ComponentReference ref = null;
317	7	if (comp != null && resolver.getHierarchy().contains(comp)) {
318	2	ref = resolver.getComponentReference(comp);
319		}
320	7	if (ref != selectedReference) {
321	0	selectedReference = ref;
322	0	updateReferenceSelection(ref);
323		}
324	7	if (ref == null && !showingHierarchy()) {
325	0	tabs.setSelectedIndex(TAB_HIERARCHY);
326		}
327	7	updateComponentSelection(comp);
328	7	fireSelectionChanged();
329		}
330
331		/** Return the row index of the given component reference. */
332	0	private int getRow(ComponentReference ref) {
333	0	if (ref != null) {
334	0	for (int i=0;i < refTable.getRowCount();i++) {
335	0	ComponentReference value = (ComponentReference)
336		refTable.getValueAt(i, 0);
337	0	if (ref == value) {
338	0	return i;
339		}
340		}
341		}
342	0	return -1;
343		}
344
345		/** Flag to avoid responding to list/tree selection changes when they're
346		* made programmatically instead of by the user.
347		*/
348		private boolean ignoreHierarchyChange = false;
349		private boolean ignoreReferenceChange = false;
350
351		/** Set the appropriate selection in the reference list. */
352	0	private void updateReferenceSelection(ComponentReference ref) {
353	0	if (!showingHierarchy()) {
354	0	int row = getRow(ref);
355	0	ignoreReferenceChange = true;
356	0	if (row == -1) {
357	0	refTable.clearSelection();
358		}
359		else {
360	0	refTable.setRowSelectionInterval(row, row);
361		}
362	0	ignoreReferenceChange = false;
363		}
364	0	updateAttributesList();
365	0	updatePropertyList();
366		}
367
368		/** Set the appropriate selection in the component hierarchy tree. */
369	7	private void updateComponentSelection(Component comp) {
370	7	if (showingHierarchy()) {
371	7	ignoreHierarchyChange = true;