source: trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/swing/DlgInsert.java @ 228

Last change on this file since 228 was 226, checked in by sherbold, 13 years ago
  • fixed a couple of code smells
  • Property svn:mime-type set to text/plain
File size: 17.1 KB
Line 
1package de.ugoe.cs.eventbench.swing;
2
3import java.awt.BorderLayout;
4import java.util.Enumeration;
5import java.util.List;
6import java.util.SortedSet;
7import java.util.TreeSet;
8
9import de.ugoe.cs.eventbench.assertions.AssertEvent;
10import de.ugoe.cs.eventbench.assertions.FileEqualsReplay;
11import de.ugoe.cs.eventbench.assertions.TextEqualsReplay;
12import de.ugoe.cs.eventbench.data.Event;
13import de.ugoe.cs.eventbench.data.GlobalDataContainer;
14import de.ugoe.cs.util.console.Console;
15
16import javax.swing.JButton;
17import javax.swing.JDialog;
18import javax.swing.JPanel;
19import javax.swing.border.EmptyBorder;
20import javax.swing.JComboBox;
21import javax.swing.JLabel;
22import javax.swing.JTextField;
23import javax.swing.JOptionPane;
24import javax.swing.JFileChooser;
25import java.awt.event.MouseAdapter;
26import java.awt.event.MouseEvent;
27import java.io.File;
28import java.awt.event.ActionListener;
29import java.awt.event.ActionEvent;
30import javax.swing.JScrollPane;
31import javax.swing.border.EtchedBorder;
32import javax.swing.JTree;
33import javax.swing.tree.DefaultTreeModel;
34import javax.swing.tree.DefaultMutableTreeNode;
35import javax.swing.tree.TreeNode;
36import javax.swing.tree.TreePath;
37import javax.swing.tree.TreeSelectionModel;
38
39/**
40 * <p>
41 * This class provides the dialog to insert one of the available assertion
42 * types.
43 * </p>
44 *
45 * @author Jeffrey Hall
46 * @version 1.0
47 */
48public class DlgInsert extends JDialog {
49
50        /**
51         * Id for object serialization.
52         */
53        private static final long serialVersionUID = 1L;
54
55        private final JPanel contentPanel = new JPanel();
56        private JTextField textFieldExpectedValue;
57        private JTextField textFieldActualFile;
58        private JTextField textFieldExpectedFile;
59
60        /**
61         * <p>
62         * Launch the dialog
63         * </p>
64         *
65         * @param sequences
66         *            A list of the events where an assertion will be inserted.
67         * @param selectedIndex
68         *            The position for inserting an assertion.
69         * @param insertBefore
70         *            To decide if the user clicked 'insert before' or 'insert
71         *            after'.
72         */
73        public static void showDialog(List<Event<?>> sequences, int selectedIndex,
74                        final boolean insertBefore) {
75                try {
76                        DlgInsert dialog = new DlgInsert(sequences, selectedIndex,
77                                        insertBefore);
78                        dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
79                        dialog.setVisible(true);
80                } catch (Exception e) {
81                        e.printStackTrace();
82                }
83        }
84
85        /**
86         * <p>
87         * Create the dialog.
88         * </p>
89         *
90         * @param sequences
91         *            A list of the events where an assertion will be inserted.
92         * @param selectedIndex
93         *            The position for inserting an assertion.
94         * @param insertBefore
95         *            To decide if the user clicked 'insert before' or 'insert
96         *            after'.
97         */
98        public DlgInsert(final List<Event<?>> sequences, final int selectedIndex,
99                        final boolean insertBefore) {
100                initialize(sequences, selectedIndex, insertBefore);
101        }
102
103        /**
104         * <p>
105         * Initialize the contents of the frame.
106         * </p>
107         *
108         * @param sequences
109         *            A list of the events where an assertion will be inserted.
110         * @param selectedIndex
111         *            The position for inserting an assertion.
112         * @param insertBefore
113         *            To decide if the user clicked 'insert before' or 'insert
114         *            after'.
115         */
116        private void initialize(final List<Event<?>> sequences,
117                        final int selectedIndex, final boolean insertBefore) {
118
119                setResizable(false);
120
121                setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
122                setTitle("Insert testcase");
123
124                setModal(true);
125                setBounds(100, 100, 676, 673);
126                getContentPane().setLayout(new BorderLayout());
127                contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
128                getContentPane().add(contentPanel, BorderLayout.CENTER);
129                contentPanel.setLayout(null);
130                final JComboBox comboBoxAssertionType = new JComboBox();
131                final JPanel panelTextEquals = new JPanel();
132                panelTextEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
133                                null));
134                final JPanel panelFileEquals = new JPanel();
135                panelFileEquals.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
136                                null));
137
138                // *****
139                // define your assertion types here
140                final int numberOfAssertionTypes = 2;
141                final JPanel[] panels = new JPanel[numberOfAssertionTypes];
142                String[] assertionTypes = new String[numberOfAssertionTypes];
143
144                panels[0] = panelTextEquals;
145                assertionTypes[0] = "TextEquals";
146                panels[1] = panelFileEquals;
147                assertionTypes[1] = "OutputFileEquals";
148                // *****
149
150                // add assertion types to comboBox
151                for (int i = 0; i < numberOfAssertionTypes; i++) {
152                        comboBoxAssertionType.addItem(assertionTypes[i]);
153                }
154
155                comboBoxAssertionType.setSelectedIndex(0);
156                comboBoxAssertionType.setBounds(90, 11, 180, 20);
157                contentPanel.add(comboBoxAssertionType);
158
159                final JPanel buttonPane = new JPanel();
160                final JButton okButton = new JButton("Insert");
161
162                // selecting of another assertion type
163                comboBoxAssertionType.addActionListener(new ActionListener() {
164                        public void actionPerformed(ActionEvent arg0) {
165                                if ("comboBoxChanged".equals(arg0.getActionCommand())) {
166
167                                        selectAssertionType(numberOfAssertionTypes, panels,
168                                                        comboBoxAssertionType.getSelectedIndex(),
169                                                        buttonPane, okButton);
170                                }
171                        }
172                });
173
174                JLabel label = new JLabel("Testcase:");
175                label.setBounds(12, 14, 86, 14);
176                contentPanel.add(label);
177
178                JLabel label_1 = new JLabel("Expected value:");
179                label_1.setBounds(10, 11, 96, 14);
180
181                JLabel label_2 = new JLabel("Target:");
182                label_2.setBounds(10, 38, 86, 14);
183
184                textFieldExpectedValue = new JTextField();
185                textFieldExpectedValue.setColumns(10);
186                textFieldExpectedValue.setBounds(116, 8, 524, 20);
187
188                panelTextEquals.setLayout(null);
189                panelTextEquals.setBounds(10, 40, 650, 401);
190                contentPanel.add(panelTextEquals);
191                panelTextEquals.add(label_1);
192                panelTextEquals.add(label_2);
193                panelTextEquals.add(textFieldExpectedValue);
194
195                JScrollPane scrollPane_1 = new JScrollPane();
196                scrollPane_1.setBounds(10, 58, 630, 291);
197                panelTextEquals.add(scrollPane_1);
198
199                final JTree tree = new JTree();
200                DefaultTreeModel treeModel = new DefaultTreeModel(null);
201                final DefaultMutableTreeNode root = new DefaultMutableTreeNode(
202                                "Targets");
203                treeModel.setRoot(root);
204                tree.setModel(treeModel);
205
206                tree.getSelectionModel().setSelectionMode(
207                                TreeSelectionModel.CONTIGUOUS_TREE_SELECTION);
208                buildTargetTree(root);
209
210                scrollPane_1.setViewportView(tree);
211
212                // expand all targets
213                JButton btnExpandAll = new JButton("Expand all");
214                btnExpandAll.addMouseListener(new MouseAdapter() {
215                        public void mouseClicked(MouseEvent arg0) {
216
217                                expandAll(tree, new TreePath(root), true);
218                        }
219                });
220                btnExpandAll.setBounds(10, 360, 112, 30);
221                panelTextEquals.add(btnExpandAll);
222
223                // collapse all targets
224                JButton btnCollapseAll = new JButton("Collapse all");
225                btnCollapseAll.addMouseListener(new MouseAdapter() {
226                        public void mouseClicked(MouseEvent arg0) {
227                                expandAll(tree, new TreePath(root), false);
228                        }
229                });
230                btnCollapseAll.setBounds(132, 360, 112, 30);
231                panelTextEquals.add(btnCollapseAll);
232
233                panelFileEquals.setBounds(34, 452, 607, 120);
234                contentPanel.add(panelFileEquals);
235                panelFileEquals.setLayout(null);
236                panelFileEquals.setVisible(false);
237
238                JLabel lblNewLabel = new JLabel("Actual file:");
239                lblNewLabel.setBounds(10, 11, 89, 14);
240                panelFileEquals.add(lblNewLabel);
241
242                textFieldActualFile = new JTextField();
243                textFieldActualFile.setBounds(10, 30, 587, 20);
244                panelFileEquals.add(textFieldActualFile);
245                textFieldActualFile.setColumns(10);
246
247                // open search file dialog
248                JButton btnSearchFile = new JButton("Search file");
249                btnSearchFile.addMouseListener(new MouseAdapter() {
250                        public void mouseClicked(MouseEvent arg0) {
251                                final JFileChooser fc = new JFileChooser();
252                                if (fc.showOpenDialog(contentPanel) == 0) {
253                                        textFieldExpectedFile.setText(fc.getSelectedFile()
254                                                        .getAbsolutePath());
255                                }
256                        }
257                });
258                btnSearchFile.setBounds(93, 61, 89, 23);
259                panelFileEquals.add(btnSearchFile);
260
261                JLabel lblNewLabel_1 = new JLabel("Expected file:");
262                lblNewLabel_1.setBounds(10, 70, 89, 14);
263                panelFileEquals.add(lblNewLabel_1);
264
265                textFieldExpectedFile = new JTextField();
266                textFieldExpectedFile.setColumns(10);
267                textFieldExpectedFile.setBounds(10, 88, 587, 20);
268                panelFileEquals.add(textFieldExpectedFile);
269
270                {
271                        buttonPane.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null,
272                                        null));
273                        buttonPane.setBounds(12, 583, 607, 51);
274                        contentPanel.add(buttonPane);
275                        {
276                                // clicking 'Insert'
277                                okButton.setBounds(462, 11, 135, 31);
278                                okButton.addMouseListener(new MouseAdapter() {
279                                        public void mouseClicked(MouseEvent arg0) {
280                                                if (insertAssertion(sequences, selectedIndex,
281                                                                insertBefore, tree, comboBoxAssertionType
282                                                                                .getSelectedItem().toString()) == false) {
283                                                        return;
284                                                }
285
286                                                dispose();
287                                        }
288                                });
289                                buttonPane.setLayout(null);
290                                okButton.setActionCommand("OK");
291                                buttonPane.add(okButton);
292                                getRootPane().setDefaultButton(okButton);
293                        }
294
295                        {
296                                // clicking 'Cancel'
297                                JButton cancelButton = new JButton("Cancel");
298                                cancelButton.setBounds(10, 11, 135, 31);
299                                cancelButton.addMouseListener(new MouseAdapter() {
300
301                                        public void mouseClicked(MouseEvent arg0) {
302                                                dispose();
303                                        }
304                                });
305                                cancelButton.setActionCommand("Cancel");
306                                buttonPane.add(cancelButton);
307                        }
308                }
309               
310                selectAssertionType(numberOfAssertionTypes, panels,
311                                comboBoxAssertionType.getSelectedIndex(),
312                                buttonPane, okButton);
313        }
314
315        /**
316         * Build up the tree containing all available targets.
317         *
318         * @param root
319         *            The tree root.
320         */
321        @SuppressWarnings("unchecked")
322        private void buildTargetTree(final DefaultMutableTreeNode root) {
323                // get targets from GlobalDataContainer
324                SortedSet<String> listTargets = new TreeSet<String>();
325                try {
326                        listTargets = (SortedSet<String>) GlobalDataContainer.getInstance()
327                                        .getData("ListTargets");
328                } catch (ClassCastException e) {
329                        Console.println("Not able to cast data in GlobalDataContainer to SortedSet of Strings");
330                }
331
332                // build the tree
333                for (String target : listTargets) {
334                        DefaultMutableTreeNode currentParent = root;
335
336                        String splitted[] = target.split("/>");
337
338                        for (String targetPart : splitted) {
339                                DefaultMutableTreeNode node = compareTargetWithNode(
340                                                currentParent, targetPart + "/>");
341
342                                if (node != null) {
343                                        currentParent = node;
344                                } else {
345                                        node = new DefaultMutableTreeNode(targetPart + "/>");
346                                        currentParent.add(node);
347                                        currentParent = node;
348                                }
349                        }
350                }
351        }
352
353        /**
354         * Check if there is a child equal to 'target'.
355         *
356         * @param node
357         *            The parent node which is browsed for a node equal to 'target'.
358         * @param target
359         *            'node' is browsed for this String.
360         * @return If there was no fitting node found, the return value is null.
361         *         Otherwise it is the node.
362         */
363        DefaultMutableTreeNode compareTargetWithNode(DefaultMutableTreeNode node,
364                        String target) {
365
366                if (node.isLeaf()) {
367                        if (target.contains(node.toString()))
368                                return node;
369                        else
370                                return null;
371                } else {
372                        for (@SuppressWarnings("unchecked")
373                        Enumeration<DefaultMutableTreeNode> e = node.children(); e
374                                        .hasMoreElements();) {
375                                DefaultMutableTreeNode nodeReturn = compareTargetWithNode(
376                                                e.nextElement(), target);
377                                if (nodeReturn == null) {
378                                        if (target.contains(node.toString())) {
379                                                return node;
380                                        }
381                                } else {
382                                        return nodeReturn;
383                                }
384                        }
385                }
386
387                return null;
388        }
389
390        /**
391         * Expand or collapse the target tree.
392         *
393         * @param tree
394         *            The tree itself.
395         * @param parent
396         *            The parent node which has to be expanded/collapsed.
397         * @param expand
398         *            To choose wether it is expanded or collapsed.
399         */
400        private void expandAll(JTree tree, TreePath parent, boolean expand) {
401                // Traverse children
402                TreeNode node = (TreeNode) parent.getLastPathComponent();
403                if (node.getChildCount() >= 0) {
404                        for (@SuppressWarnings("unchecked")
405                        Enumeration<DefaultMutableTreeNode> e = node.children(); e
406                                        .hasMoreElements();) {
407                                TreeNode n = e.nextElement();
408                                TreePath path = parent.pathByAddingChild(n);
409                                expandAll(tree, path, expand);
410                        }
411                }
412
413                // Expansion or collapse must be done bottom-up
414                if (expand) {
415                        tree.expandPath(parent);
416                } else {
417                        tree.collapsePath(parent);
418                }
419        }
420
421        /**
422         * Select another assertion type in the comboBox.
423         *
424         * @param numberOfAssertionTypes
425         *            Number of available assertion types.
426         * @param panels
427         *            The corresponding panels of the types.
428         * @param selectedIndex
429         *            The index of the selected type.
430         * @param buttonPane
431         *            The buttonPane of the dialog.
432         * @param okButton
433         *            The okButton of the buttonPane.
434         */
435        private void selectAssertionType(final int numberOfAssertionTypes,
436                        final JPanel[] panels, int selectedIndex, final JPanel buttonPane,
437                        final JButton okButton) {
438                for (int i = 0; i < numberOfAssertionTypes; i++) {
439                        panels[i].setVisible(false);
440                }
441
442                JPanel activePanel = panels[selectedIndex];
443                activePanel.setVisible(true);
444                activePanel.setLocation(10, 40);
445
446                buttonPane.setLocation(activePanel.getX(), activePanel.getY()
447                                + activePanel.getHeight() + 15);
448                buttonPane.setSize(activePanel.getWidth(), buttonPane.getHeight());
449                setSize(activePanel.getX() + activePanel.getSize().width + 15,
450                                buttonPane.getY() + buttonPane.getSize().height + 35);
451                okButton.setLocation(buttonPane.getWidth() - okButton.getWidth() - 10,
452                                okButton.getY());
453
454        }
455
456        /**
457         * To check if all the parameters needed where entered correctly.
458         *
459         * @param sequences
460         *            A list of the events where an assertion will be inserted.
461         * @param selectedIndex
462         *            The position for inserting an assertion.
463         * @param insertBefore
464         *            To decide if the user clicked 'insert before' or 'insert
465         *            after'.
466         * @param tree
467         *            The target tree.
468         * @param selectedItem
469         *            To identify the selected assertion type.
470         * @return If the assertion was inserted, the return value is true.
471         *         Otherwise it is false.
472         */
473        private boolean insertAssertion(final List<Event<?>> sequences,
474                        final int selectedIndex, final boolean insertBefore,
475                        final JTree tree, final String selectedItem) {
476
477                // FileEquals
478                if (selectedItem == "OutputFileEquals") {
479                        if (textFieldActualFile.getText().length() == 0) {
480                                JOptionPane.showMessageDialog(null,
481                                                "Please declare an actual file.",
482                                                "No actual file declared", JOptionPane.OK_OPTION);
483
484                                return false;
485                        } else if (!new File(textFieldExpectedFile.getText()).exists()) {
486                                if (textFieldExpectedFile.getText().length() == 0) {
487                                        JOptionPane.showMessageDialog(null,
488                                                        "Please choose an expected file.",
489                                                        "No expected file chosen", JOptionPane.OK_OPTION);
490                                } else {
491                                        JOptionPane.showMessageDialog(null, "The expected file \""
492                                                        + textFieldActualFile.getText()
493                                                        + "\" does not exist.",
494                                                        "Expected file does not exist",
495                                                        JOptionPane.OK_OPTION);
496                                }
497
498                                return false;
499                        } else {
500                                FileEqualsReplay file = new FileEqualsReplay();
501                                file.setActualFile(textFieldActualFile.getText());
502                                file.setExpectedFile(textFieldExpectedFile.getText());
503
504                                AssertEvent<FileEqualsReplay> e = new AssertEvent<FileEqualsReplay>(
505                                                "FileEquals");
506                                e.addReplayEvent(file);
507                                e.setTarget(" ");
508                                if (insertBefore)
509                                        sequences.add(selectedIndex, e);
510                                else
511                                        sequences.add(selectedIndex + 1, e);
512                        }
513                }
514                // TextEquals
515                else if (selectedItem == "TextEquals") {
516                        if (textFieldExpectedValue.getText().length() == 0) {
517                                JOptionPane.showMessageDialog(null,
518                                                "\"Expected value\" is missing.", "Expected value",
519                                                JOptionPane.OK_OPTION);
520                                return false;
521                        } else if (tree.getSelectionCount() == 0
522                                        || tree.getSelectionPath().toString()
523                                                        .compareTo("[Targets]") == 0) {
524                                JOptionPane.showMessageDialog(null, "Please select a target.",
525                                                "No target selected", JOptionPane.OK_OPTION);
526                                return false;
527                        } else {
528
529                                // get target ***
530                                String selectionPath = tree.getSelectionPath().toString();
531
532                                // remove leading and ending brackets
533                                selectionPath = selectionPath.substring(1);
534                                selectionPath = selectionPath.substring(0,
535                                                selectionPath.length() - 1);
536                                // remove leading string "targets"
537                                selectionPath = selectionPath.substring(7);
538
539                                String splitted[] = selectionPath.toString().split(", ");
540
541                                // get all parents
542                                String target = "";
543                                for (int i = 0; i < splitted.length; i++) {
544                                        target += splitted[i];
545                                }
546                                // ***
547
548                                TextEqualsReplay text = new TextEqualsReplay();
549                                text.setExpectedValue(textFieldExpectedValue.getText());
550                                text.setTarget(target);
551
552                                AssertEvent<TextEqualsReplay> e = new AssertEvent<TextEqualsReplay>(
553                                                "TextEquals");
554                                e.addReplayEvent(text);
555                                e.setTarget(" ");
556                                if (insertBefore)
557                                        sequences.add(selectedIndex, e);
558                                else
559                                        sequences.add(selectedIndex + 1, e);
560                        }
561                }
562
563                return true;
564        }
565}
Note: See TracBrowser for help on using the repository browser.