KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jmeter > protocol > http > gui > HeaderPanel


1 // $Header: /home/cvs/jakarta-jmeter/src/protocol/http/org/apache/jmeter/protocol/http/gui/HeaderPanel.java,v 1.15.2.1 2004/11/07 00:20:42 sebb Exp $
2
/*
3  * Copyright 2001-2004 The Apache Software Foundation.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17 */

18
19 package org.apache.jmeter.protocol.http.gui;
20
21 import java.awt.BorderLayout JavaDoc;
22 import java.awt.Dimension JavaDoc;
23 import java.awt.GridBagConstraints JavaDoc;
24 import java.awt.GridBagLayout JavaDoc;
25 import java.awt.event.ActionEvent JavaDoc;
26 import java.awt.event.ActionListener JavaDoc;
27 import java.awt.event.FocusEvent JavaDoc;
28 import java.awt.event.FocusListener JavaDoc;
29 import java.io.File JavaDoc;
30 import java.io.IOException JavaDoc;
31
32 import javax.swing.BorderFactory JavaDoc;
33 import javax.swing.JButton JavaDoc;
34 import javax.swing.JDialog JavaDoc;
35 import javax.swing.JLabel JavaDoc;
36 import javax.swing.JPanel JavaDoc;
37 import javax.swing.JScrollPane JavaDoc;
38 import javax.swing.JTable JavaDoc;
39 import javax.swing.JTextField JavaDoc;
40 import javax.swing.ListSelectionModel JavaDoc;
41 import javax.swing.table.AbstractTableModel JavaDoc;
42 import javax.swing.table.TableCellEditor JavaDoc;
43
44 import org.apache.jmeter.config.gui.AbstractConfigGui;
45 import org.apache.jmeter.gui.util.FileDialoger;
46 import org.apache.jmeter.protocol.http.control.Header;
47 import org.apache.jmeter.protocol.http.control.HeaderManager;
48 import org.apache.jmeter.testelement.TestElement;
49 import org.apache.jmeter.util.JMeterUtils;
50 import org.apache.jorphan.logging.LoggingManager;
51 import org.apache.log.Logger;
52
53 /**
54  * Allows the user to specify if she needs HTTP header services, and give
55  * parameters for this service.
56  *
57  * @version $Revision: 1.15.2.1 $
58  */

59 public class HeaderPanel
60     extends AbstractConfigGui
61     implements ActionListener JavaDoc, FocusListener JavaDoc
62 {
63     transient private static Logger log = LoggingManager.getLoggerForClass();
64
65     private static final String JavaDoc ADD_COMMAND = "Add";
66     private static final String JavaDoc DELETE_COMMAND = "Delete";
67     private static final String JavaDoc LOAD_COMMAND = "Load";
68     private static final String JavaDoc SAVE_COMMAND = "Save";
69
70     private InnerTableModel tableModel;
71
72     /**
73      * A table to show the authentication information.
74      */

75     private JTable JavaDoc headerTable;
76
77     private JButton JavaDoc addButton;
78     private JButton JavaDoc deleteButton;
79     private JButton JavaDoc loadButton;
80     private JButton JavaDoc saveButton;
81
82     /**
83      * Default constructor.
84      */

85     public HeaderPanel()
86     {
87         tableModel = new InnerTableModel();
88         init();
89     }
90
91     public TestElement createTestElement()
92     {
93         HeaderManager headerManager = tableModel.manager;
94         configureTestElement(headerManager);
95         return (TestElement) headerManager.clone();
96     }
97
98     /**
99      * Modifies a given TestElement to mirror the data in the gui components.
100      * @see org.apache.jmeter.gui.JMeterGUIComponent#modifyTestElement(TestElement)
101      */

102     public void modifyTestElement(TestElement el)
103     {
104         el.clear();
105         el.addTestElement(tableModel.manager);
106         configureTestElement(el);
107     }
108
109     public void configure(TestElement el)
110     {
111         tableModel.manager.clear();
112         super.configure(el);
113         tableModel.manager.addTestElement((HeaderManager) el);
114         boolean hasRows = tableModel.getRowCount() > 0;
115         deleteButton.setEnabled(hasRows);
116         saveButton.setEnabled(hasRows);
117         
118     }
119
120     public String JavaDoc getLabelResource()
121     {
122         return "header_manager_title";
123     }
124
125     /**
126      * Gets a HeaderManager to manage the file that is currently selected. Null
127      * is returned if no file is currently selected. Null will also be returned
128      * if there is a problem reading the file while getting the HeaderManager.
129      *
130      * @returns a HeaderManager for the current file, or null
131      *
132      * public HeaderManager
133      * getHeaderMgr() { return manager; }
134      */

135
136     /**
137      * Shows the main header configuration panel.
138      */

139     public void init()
140     {
141         setLayout(new BorderLayout JavaDoc());
142         setBorder(makeBorder());
143
144         add(makeTitlePanel(), BorderLayout.NORTH);
145         add(createHeaderTablePanel(), BorderLayout.CENTER);
146     }
147
148     public void actionPerformed(ActionEvent JavaDoc e)
149     {
150         String JavaDoc action = e.getActionCommand();
151
152         if (action.equals("Delete"))
153         {
154             if (tableModel.getRowCount() > 0)
155             {
156                 // If a table cell is being edited, we must cancel the editing
157
// before deleting the row.
158
if (headerTable.isEditing())
159                 {
160                     TableCellEditor JavaDoc cellEditor =
161                         headerTable.getCellEditor(
162                             headerTable.getEditingRow(),
163                             headerTable.getEditingColumn());
164                     cellEditor.cancelCellEditing();
165                 }
166
167                 int rowSelected = headerTable.getSelectedRow();
168
169                 if (rowSelected != -1)
170                 {
171                     tableModel.removeRow(rowSelected);
172                     tableModel.fireTableDataChanged();
173
174                     // Disable the DELETE and SAVE buttons if no rows remaining
175
// after delete
176
if (tableModel.getRowCount() == 0)
177                     {
178                         deleteButton.setEnabled(false);
179                         saveButton.setEnabled(false);
180                     }
181
182                     // Table still contains one or more rows, so highlight
183
// (select) the appropriate one.
184
else
185                     {
186                         int rowToSelect = rowSelected;
187
188                         if (rowSelected >= tableModel.getRowCount())
189                         {
190                             rowToSelect = rowSelected - 1;
191                         }
192
193                         headerTable.setRowSelectionInterval(
194                             rowToSelect,
195                             rowToSelect);
196                     }
197                 }
198             }
199         }
200         else if (action.equals("Add"))
201         {
202             // If a table cell is being edited, we should accept the current
203
// value and stop the editing before adding a new row.
204
if (headerTable.isEditing())
205             {
206                 TableCellEditor JavaDoc cellEditor =
207                     headerTable.getCellEditor(
208                         headerTable.getEditingRow(),
209                         headerTable.getEditingColumn());
210                 cellEditor.stopCellEditing();
211             }
212
213             tableModel.addNewRow();
214             tableModel.fireTableDataChanged();
215
216             // Enable the DELETE and SAVE buttons if they are currently
217
// disabled.
218
if (!deleteButton.isEnabled())
219             {
220                 deleteButton.setEnabled(true);
221             }
222             if (!saveButton.isEnabled())
223             {
224                 saveButton.setEnabled(true);
225             }
226
227             // Highlight (select) the appropriate row.
228
int rowToSelect = tableModel.getRowCount() - 1;
229             headerTable.setRowSelectionInterval(rowToSelect, rowToSelect);
230         }
231         else if (action.equals("Load"))
232         {
233             try
234             {
235                 File JavaDoc tmp = FileDialoger.promptToOpenFile().getSelectedFile();
236                 if (tmp != null)
237                 {
238                     tableModel.manager.addFile(tmp.getAbsolutePath());
239                     tableModel.fireTableDataChanged();
240
241                     if (tableModel.getRowCount() > 0)
242                     {
243                         deleteButton.setEnabled(true);
244                         saveButton.setEnabled(true);
245                     }
246                 }
247             }
248             catch (IOException JavaDoc ex)
249             {
250                 log.error("", ex);
251             }
252             catch (NullPointerException JavaDoc err)
253             {
254             }
255         }
256         else if (action.equals("Save"))
257         {
258             try
259             {
260                 File JavaDoc tmp =
261                     FileDialoger.promptToSaveFile(null).getSelectedFile();
262                 if (tmp != null)
263                 {
264                     tableModel.manager.save(tmp.getAbsolutePath());
265                 }
266             }
267             catch (IOException JavaDoc ex)
268             {
269                 log.error("", ex);
270             }
271             catch (NullPointerException JavaDoc err)
272             {
273             }
274         }
275     }
276
277     public JPanel JavaDoc createHeaderTablePanel()
278     {
279         // create the JTable that holds header per row
280
headerTable = new JTable JavaDoc(tableModel);
281         headerTable.addFocusListener(this);
282         headerTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
283         headerTable.setPreferredScrollableViewportSize(new Dimension JavaDoc(100, 70));
284
285         JPanel JavaDoc panel = new JPanel JavaDoc(new BorderLayout JavaDoc(0, 5));
286         panel.setBorder(
287             BorderFactory.createTitledBorder(
288                 BorderFactory.createEtchedBorder(),
289                 JMeterUtils.getResString("headers_stored")));
290         panel.add(new JScrollPane JavaDoc(headerTable), BorderLayout.CENTER);
291         panel.add(createButtonPanel(), BorderLayout.SOUTH);
292         return panel;
293     }
294
295     private JButton JavaDoc createButton(
296         String JavaDoc resName,
297         char mnemonic,
298         String JavaDoc command,
299         boolean enabled)
300     {
301         JButton JavaDoc button = new JButton JavaDoc(JMeterUtils.getResString(resName));
302         button.setMnemonic(mnemonic);
303         button.setActionCommand(command);
304         button.setEnabled(enabled);
305         button.addActionListener(this);
306         return button;
307     }
308
309     private JPanel JavaDoc createButtonPanel()
310     {
311         boolean tableEmpty = (tableModel.getRowCount() == 0);
312
313         addButton = createButton("add", 'A', ADD_COMMAND, true);
314         deleteButton = createButton("delete", 'D', DELETE_COMMAND, !tableEmpty);
315         loadButton = createButton("load", 'L', LOAD_COMMAND, true);
316         saveButton = createButton("save", 'S', SAVE_COMMAND, !tableEmpty);
317
318         JPanel JavaDoc buttonPanel = new JPanel JavaDoc();
319         buttonPanel.add(addButton);
320         buttonPanel.add(deleteButton);
321         buttonPanel.add(loadButton);
322         buttonPanel.add(saveButton);
323         return buttonPanel;
324     }
325
326     /**
327      * Updates a header record.
328      *
329      * @version $Revision: 1.15.2.1 $
330      */

331     class HeaderUpdater implements ActionListener JavaDoc
332     {
333         JTextField JavaDoc nameField = new JTextField JavaDoc(20);
334         JTextField JavaDoc valueField = new JTextField JavaDoc(20);
335         JButton JavaDoc ok = new JButton JavaDoc("Ok");
336         JButton JavaDoc cancel = new JButton JavaDoc("Cancel");
337         int index;
338
339         JDialog JavaDoc updateDialog;
340
341         public HeaderUpdater()
342         {
343         }
344
345         /**
346          * Returns the contructed panel containing the header record.
347          */

348         public JPanel JavaDoc getPanel()
349         {
350             JPanel JavaDoc main = new JPanel JavaDoc();
351             GridBagLayout JavaDoc g = new GridBagLayout JavaDoc();
352
353             main.setLayout(g);
354             GridBagConstraints JavaDoc c = new GridBagConstraints JavaDoc();
355             c.fill = GridBagConstraints.BOTH;
356             c.gridwidth = 1;
357             c.gridheight = 1;
358             JLabel JavaDoc nameLabel =
359                 new JLabel JavaDoc(JMeterUtils.getResString("name") + ":");
360             c.gridx = 1;
361             c.gridy = 1;
362             g.setConstraints(nameLabel, c);
363             main.add(nameLabel);
364             JLabel JavaDoc valueLabel =
365                 new JLabel JavaDoc(JMeterUtils.getResString("value") + ":");
366             c.gridx = 1;
367             c.gridy = 2;
368             g.setConstraints(valueLabel, c);
369             main.add(valueLabel);
370
371             c.gridx = 2;
372             c.gridy = 1;
373             g.setConstraints(nameField, c);
374             main.add(nameField);
375             c.gridx = 2;
376             c.gridy = 2;
377             g.setConstraints(valueField, c);
378             main.add(valueField);
379
380             JPanel JavaDoc buttons = new JPanel JavaDoc();
381             ok.setPreferredSize(cancel.getPreferredSize());
382             buttons.add(ok);
383             buttons.add(cancel);
384             c.gridwidth = 2;
385             c.gridx = 1;
386             c.gridy = 7;
387             g.setConstraints(buttons, c);
388             main.add(buttons);
389
390             return main;
391         }
392
393         public void actionPerformed(ActionEvent JavaDoc e)
394         {
395             String JavaDoc command = e.getActionCommand();
396             boolean valid = true;
397             index = -1;
398             if (command.equals("Edit"))
399             {
400                 index = headerTable.getSelectedRow();
401                 if (index < 0)
402                 {
403                     valid = false;
404                 }
405                 else
406                 {
407                     Header c = tableModel.manager.get(index);
408                     nameField = new JTextField JavaDoc(c.getName(), 20);
409                     valueField = new JTextField JavaDoc(c.getValue(), 20);
410                     ok = new JButton JavaDoc("Ok");
411                     cancel = new JButton JavaDoc("Cancel");
412                 }
413             }
414             else if (command.equals("Add"))
415             {
416                 nameField = new JTextField JavaDoc(20);
417                 valueField = new JTextField JavaDoc(20);
418                 ok = new JButton JavaDoc("Ok");
419                 cancel = new JButton JavaDoc("Cancel");
420             }
421             if (valid)
422             {
423                 if (updateDialog != null)
424                 {
425                     updateDialog.dispose();
426                 }
427                 updateDialog = new JDialog JavaDoc();
428                 updateDialog.setSize(350, 300);
429
430                 ok.addActionListener(new ActionListener JavaDoc()
431                 {
432                     public void actionPerformed(ActionEvent JavaDoc ev)
433                     {
434                         int i = index;
435                         Header c = new Header();
436                         if (i >= 0)
437                         {
438                             c = tableModel.manager.get(index);
439                         }
440                         c.setName(nameField.getText());
441                         c.setValue(valueField.getText());
442                         if (i < 0)
443                         {
444                             tableModel.manager.add(c);
445                         }
446                         tableModel.fireTableDataChanged();
447                         updateDialog.dispose();
448                     }
449                 });
450                 cancel.addActionListener(new ActionListener JavaDoc()
451                 {
452                     public void actionPerformed(ActionEvent JavaDoc ev)
453                     {
454                         updateDialog.dispose();
455                     }
456                 });
457                 updateDialog.getContentPane().add(getPanel());
458                 updateDialog.show();
459             }
460         }
461     }
462
463     public void focusGained(FocusEvent JavaDoc e)
464     {
465     }
466
467     public void focusLost(FocusEvent JavaDoc e)
468     {
469         try
470         {
471             headerTable.getCellEditor().stopCellEditing();
472         }
473         catch (RuntimeException JavaDoc err)
474         {
475         }
476     }
477
478     /**
479      * @version $Revision: 1.15.2.1 $
480      */

481     private class InnerTableModel extends AbstractTableModel JavaDoc
482     {
483         HeaderManager manager;
484
485         public InnerTableModel(HeaderManager man)
486         {
487             manager = man;
488         }
489
490         public InnerTableModel()
491         {
492             manager = new HeaderManager();
493         }
494
495         public void removeRow(int row)
496         {
497             manager.remove(row);
498         }
499
500         public void addNewRow()
501         {
502             manager.add();
503         }
504
505         public boolean isCellEditable(int row, int column)
506         {
507             // all table cells are editable
508
return true;
509         }
510
511         public Class JavaDoc getColumnClass(int column)
512         {
513             return getValueAt(0, column).getClass();
514         }
515
516         public int getRowCount()
517         {
518             return manager.getHeaders().size();
519         }
520
521         /**
522          * Required by table model interface.
523          */

524         public int getColumnCount()
525         {
526             return manager.getColumnCount();
527         }
528
529         /**
530          * Required by table model interface.
531          */

532         public String JavaDoc getColumnName(int column)
533         {
534             return manager.getColumnName(column);
535         }
536
537         /**
538          * Required by table model interface.
539          */

540         public Object JavaDoc getValueAt(int row, int column)
541         {
542             Header head = manager.getHeader(row);
543             if (column == 0)
544             {
545                 return head.getName();
546             }
547             else if (column == 1)
548             {
549                 return head.getValue();
550             }
551             return null;
552         }
553
554         /**
555          * Required by table model interface.
556          */

557         public void setValueAt(Object JavaDoc value, int row, int column)
558         {
559             Header header = manager.getHeader(row);
560
561             if (column == 0)
562             {
563                 header.setName((String JavaDoc) value);
564             }
565             else if (column == 1)
566             {
567                 header.setValue((String JavaDoc) value);
568             }
569         }
570
571     }
572 }
573
Popular Tags