6231d8aac3db6f9631cf70c5c82e2dbf38990ec5
[mirror_edk2.git] / Tools / Source / FrameworkWizard / src / org / tianocore / frameworkwizard / platform / ui / FpdBuildOptions.java
1 /** @file
2
3 The file is used to create, update BuildOptions of Fpd file
4
5 Copyright (c) 2006, Intel Corporation
6 All rights reserved. This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15 package org.tianocore.frameworkwizard.platform.ui;
16
17 import java.awt.BorderLayout;
18
19 import javax.swing.JPanel;
20 import javax.swing.JTabbedPane;
21 import javax.swing.JCheckBox;
22 import javax.swing.JLabel;
23 import java.awt.FlowLayout;
24 import javax.swing.AbstractAction;
25 import java.awt.event.ActionEvent;
26 import java.awt.event.ActionListener;
27
28 import javax.swing.DefaultCellEditor;
29 import javax.swing.JFileChooser;
30 import javax.swing.JFrame;
31 import javax.swing.JOptionPane;
32 import javax.swing.JTextField;
33 import javax.swing.JButton;
34 import javax.swing.JScrollPane;
35 import javax.swing.JTable;
36 import javax.swing.JComboBox;
37 import javax.swing.ListSelectionModel;
38 import javax.swing.event.InternalFrameAdapter;
39 import javax.swing.event.InternalFrameEvent;
40 import javax.swing.event.ListSelectionEvent;
41 import javax.swing.event.ListSelectionListener;
42 import javax.swing.event.TableModelEvent;
43 import javax.swing.event.TableModelListener;
44 import javax.swing.table.DefaultTableModel;
45 import javax.swing.table.TableModel;
46
47 import org.tianocore.PlatformSurfaceAreaDocument;
48 import org.tianocore.frameworkwizard.common.DataValidation;
49 import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType;
50 import org.tianocore.frameworkwizard.common.ui.IInternalFrame;
51
52 import java.io.File;
53 import java.util.ArrayList;
54 import java.util.Iterator;
55 import java.util.LinkedHashMap;
56 import java.util.Set;
57 import java.util.Vector;
58 import java.awt.Dimension;
59 import javax.swing.JSplitPane;
60
61 public class FpdBuildOptions extends IInternalFrame {
62
63 private final int oneRowHeight = 20;
64
65 private final int twoRowHeight = 40;
66
67 private final int sepHeight = 6;
68
69 private final int sepWidth = 10;
70
71 private final int buttonWidth = 90;
72
73 private final int rowOne = 12;
74
75 private final int dialogWidth = 600;
76
77 private final int rowTwo = rowOne + oneRowHeight + sepHeight;
78
79 private final int rowThree = rowTwo + oneRowHeight + sepHeight;
80
81 private final int rowFour = rowThree + oneRowHeight + sepHeight;
82
83 private final int rowFive = rowFour + oneRowHeight + sepHeight;
84
85 private final int rowSix = rowFive + oneRowHeight + sepHeight;
86
87 private final int rowSeven = rowSix + oneRowHeight + sepHeight;
88
89 private final int buttonRow = rowSeven + oneRowHeight + sepHeight + sepHeight;
90
91 private final int dialogHeight = buttonRow + twoRowHeight + twoRowHeight;
92
93 private final int lastButtonXLoc = dialogWidth - buttonWidth - sepWidth;
94
95 private final int next2LastButtonLoc = lastButtonXLoc - buttonWidth - sepWidth;
96
97 private final int firstButtonLoc = next2LastButtonLoc - buttonWidth - sepWidth;
98
99 private final int labelColumn = 12;
100
101 private final int fieldColumn = 168;
102
103 private final int labelWidth = 155;
104
105 private final int fieldWidth = 320;
106
107 private static final long serialVersionUID = 1L;
108
109 static JFrame frame;
110
111 private JPanel jContentPane = null;
112
113 // private JPanel jPanelContentSouth = null;
114
115 // private JPanel jPanelContentNorth = null;
116
117 // private JPanel jPanelContentWest = null;
118
119 // private JPanel jPanelContentEast = null;
120
121 private JTabbedPane jTabbedPane = null;
122
123 private JPanel jPanelUserDef = null;
124
125 private JPanel jPanelUserDefNorth = null;
126
127 private JPanel jPanelUserDefCenter = null;
128
129 private JTextField jTextFieldAntTaskFile = null;
130
131 private JLabel jLabelAntTaskId = null;
132
133 private JTextField jTextFieldAntTaskId = null;
134
135 private JButton jButtonAntTaskAdd = null;
136
137 private JButton jButtonAntTaskDel = null;
138
139 private JTextField jTextFieldAntCmdOpts = null;
140
141 private JScrollPane jScrollPaneAntTasks = null;
142
143 private JTable jTableAntTasks = null;
144
145 private DefaultTableModel ffsTableModel = null;
146
147 private DefaultTableModel sectionsTableModel = null;
148
149 private DefaultTableModel sectionTableModel = null;
150
151 private DefaultTableModel subsectionsTableModel = null;
152
153 private DefaultTableModel antTaskTableModel = null;
154
155 private DefaultTableModel ffsAttributesTableModel = null;
156
157 private DefaultTableModel optionsTableModel = null;
158
159 private JPanel jPanelFfsTab = null;
160
161 private JPanel jPanelFfsTabCenter = null;
162
163 private JPanel jPanelFfsTabCenterN = null;
164
165 private JPanel jPanelFfsTabCenterS = null;
166
167 private JLabel jLabelFfsKey = null;
168
169 private JTextField jTextFieldFfsKey = null;
170
171 private JButton jButtonFfsAdd = null;
172
173 private JButton jButtonFfsDel = null;
174
175 private JScrollPane jScrollPaneFfsAttribs = null;
176
177 private JTable jTableFfsAttribs = null;
178
179 private JPanel jPanelOptionsTab = null;
180
181 private JLabel jLabelOptionContents = null;
182
183 private JTextField jTextFieldOptionContents = null;
184
185 private JLabel jLabelToolChainFamily = null;
186
187 private JLabel jLabelSupArch = null;
188
189 private JLabel jLabelToolCmd = null;
190
191 private JTextField jTextFieldToolCmd = null;
192
193 private JScrollPane jScrollPaneOptions = null;
194
195 private JTable jTableOptions = null;
196
197 private JLabel jTitle = null;
198
199 private JButton jButtonOptionsAdd = null;
200
201 private JButton jButtonOptionsDel = null;
202
203 private JButton jButtonFfsAttribNew = null;
204
205 private JButton jButtonFfsAttribRemove = null;
206
207 private FpdFileContents ffc = null;
208
209 private OpeningPlatformType docConsole = null;
210
211 private JPanel jArchitectureSelections = null;
212
213 private JCheckBox jCheckBoxIA32 = null;
214
215 private JCheckBox jCheckBoxIpf = null;
216
217 private JCheckBox jCheckBoxX64 = null;
218
219 private JCheckBox jCheckBoxEBC = null;
220
221 private JCheckBox jCheckBoxARM = null;
222
223 private JCheckBox jCheckBoxPPC = null;
224
225 private JLabel jLabelBuildTargets = null;
226
227 private JTextField jTextFieldBuildTargets = null;
228
229 private JTextField jTextFieldTagName = null;
230
231 private JLabel jLabelTagName = null;
232
233 private int selectedRow = -1;
234
235 private JLabel jLabelAntTaskFile = null;
236
237 private JLabel jLabelAntCmdOpts = null;
238
239 private JScrollPane jScrollPaneFfs = null;
240
241 private JTable jTableFfs = null;
242
243 private JLabel jLabelFfsSection = null;
244
245 private JScrollPane jScrollPaneFfsSection = null;
246
247 private JTable jTableFfsSection = null;
248
249 private JLabel jLabelFfsSubSections = null;
250
251 private JScrollPane jScrollPaneFfsSubSection = null;
252
253 private JTable jTableFfsSubSection = null;
254
255 private JLabel jLabelEncapType = null;
256
257 private JTextField jTextFieldEncapType = null;
258
259 private JPanel jPanelFfsAttribButtonGroup = null;
260
261 private JLabel jLabelFfsAttribs = null;
262
263 private JButton jButtonFfsSectionNew = null;
264
265 private JButton jButtonFfsSectionRemove = null;
266
267 private JButton jButtonFfsSubSectionNew = null;
268
269 private JButton jButtonFfsSubSectionRemove = null;
270
271 private JLabel jLabelFfsSections = null;
272
273 private JButton jButtonFfsSectionsNew = null;
274
275 private JButton jButtonFfsSectionsRemove = null;
276
277 private JScrollPane jScrollPaneFfsSections = null;
278
279 private JTable jTableFfsSections = null;
280
281 private JButton jButtonAntTaskFileBrowse = null;
282
283 private JTextField jTextFieldToolChainFamily = null;
284
285 private JSplitPane jSplitPaneFfsC = null;
286
287 private JPanel jPanelFfsCTop = null;
288
289 private JSplitPane jSplitPaneFfsCBottom = null;
290
291 private JPanel jPanelFfsCBottomTop = null;
292
293 private JPanel jPanelFfsCBottomBottom = null;
294
295 private JPanel jPanelSectionN = null;
296
297 private JPanel jPanelSectionC = null;
298
299 private JPanel jPanelSectionsN = null;
300
301 private JPanel jPanelSectionsC = null;
302
303 private JPanel jPanelSubSectionN = null;
304
305 private JPanel jPanelSubSectionC = null;
306
307 private JPanel jPanelOptionsContainer = null;
308
309 private JPanel jPanelUserDefCenterN = null;
310
311 private JPanel jPanelUserDefCenterC = null;
312
313 /**
314 * This method initializes jPanel
315 *
316 * @return javax.swing.JPanel
317 private JPanel getJPanelContentSouth() {
318 if (jPanelContentSouth == null) {
319 jPanelContentSouth = new JPanel();
320 }
321 return jPanelContentSouth;
322 }
323 */
324
325 /**
326 * This method initializes jPanel1
327 *
328 * @return javax.swing.JPanel
329 private JPanel getJPanelContentNorth() {
330 if (jPanelContentNorth == null) {
331 jPanelContentNorth = new JPanel();
332 }
333 return jPanelContentNorth;
334 }
335 */
336
337 /**
338 * This method initializes jPanel2
339 *
340 * @return javax.swing.JPanel
341 private JPanel getJPanelContentWest() {
342 if (jPanelContentWest == null) {
343 jPanelContentWest = new JPanel();
344 }
345 return jPanelContentWest;
346 }
347 */
348
349 /**
350 * This method initializes jPanel3
351 *
352 * @return javax.swing.JPanel
353 private JPanel getJPanelContentEast() {
354 if (jPanelContentEast == null) {
355 jPanelContentEast = new JPanel();
356 }
357 return jPanelContentEast;
358 }
359 */
360
361 /**
362 * This method initializes jTabbedPane
363 *
364 * @return javax.swing.JTabbedPane
365 */
366 private JTabbedPane getJTabbedPane() {
367 if (jTabbedPane == null) {
368 jTabbedPane = new JTabbedPane();
369 jTabbedPane.addTab("Flash Filesystem Options", null, getJPanelFfsTab(), null);
370 jTabbedPane.addTab("Tool Arguments", null, getJPanelOptionsTab(), null);
371 jTabbedPane.addTab("User Defined ANT Tasks", null, getJPanelUserDef(), null);
372 }
373 return jTabbedPane;
374 }
375
376 /**
377 * This method initializes this
378 *
379 * @return void
380 */
381 private void initialize() {
382 this.setSize(722, 577);
383 this.setTitle("Platform Build Options");
384 this.setContentPane(getJContentPane());
385 }
386
387 /**
388 * This method initializes jContentPane
389 *
390 * @return javax.swing.JPanel
391 */
392 private JPanel getJContentPane() {
393 if (jContentPane == null) {
394 jContentPane = new JPanel();
395 jContentPane.setLayout(new BorderLayout());
396 // jContentPane.add(getJPanelContentSouth(), java.awt.BorderLayout.SOUTH);
397 // jContentPane.add(getJPanelContentNorth(), java.awt.BorderLayout.NORTH);
398 // jContentPane.add(getJPanelContentWest(), java.awt.BorderLayout.WEST);
399 // jContentPane.add(getJPanelContentEast(), java.awt.BorderLayout.EAST);
400 jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
401 }
402 return jContentPane;
403 }
404
405 /**
406 * @param args
407 */
408 public static void main(String[] args) {
409 // TODO Auto-generated method stub
410 new FpdBuildOptions().setVisible(true);
411 }
412
413 /**
414 * This is the default constructor
415 */
416 public FpdBuildOptions() {
417 super();
418 initialize();
419 this.setVisible(true);
420 }
421
422 public FpdBuildOptions(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd) {
423 this();
424 ffc = new FpdFileContents(fpd);
425 init(ffc);
426 }
427
428 public FpdBuildOptions(OpeningPlatformType opt) {
429 this(opt.getXmlFpd());
430 docConsole = opt;
431 }
432
433 private void init(FpdFileContents ffc) {
434 initOptionTable();
435 initAntTaskTable();
436 initFfsTable();
437 this.addInternalFrameListener(new InternalFrameAdapter() {
438 public void internalFrameDeactivated(InternalFrameEvent e) {
439 if (jTableFfs.isEditing()) {
440 jTableFfs.getCellEditor().stopCellEditing();
441 }
442 if (jTableFfsSection.isEditing()) {
443 jTableFfsSection.getCellEditor().stopCellEditing();
444 }
445 if (jTableAntTasks.isEditing()) {
446 jTableAntTasks.getCellEditor().stopCellEditing();
447 }
448 if (jTableFfsSubSection.isEditing()) {
449 jTableFfsSubSection.getCellEditor().stopCellEditing();
450 }
451 if (jTableFfsAttribs.isEditing()) {
452 jTableFfsAttribs.getCellEditor().stopCellEditing();
453 }
454 if (jTableOptions.isEditing()) {
455 jTableOptions.getCellEditor().stopCellEditing();
456 }
457 }
458 });
459 }
460
461 /**
462 * This method initializes jPanel13
463 *
464 * @return javax.swing.JPanel
465 */
466 private JPanel getJPanelFfsTab() {
467 if (jPanelFfsTab == null) {
468 jPanelFfsTab = new JPanel();
469 jPanelFfsTab.setLayout(new BorderLayout());
470 jPanelFfsTab.add(getJPanelFfsTabCenter(), java.awt.BorderLayout.CENTER);
471 jPanelFfsTab.add(getJScrollPaneFfs(), java.awt.BorderLayout.WEST);
472 }
473 return jPanelFfsTab;
474 }
475
476 /**
477 * This method initializes jPanel18
478 *
479 * @return javax.swing.JPanel
480 */
481 private JPanel getJPanelFfsTabCenter() {
482 if (jPanelFfsTabCenter == null) {
483 jPanelFfsTabCenter = new JPanel();
484 jPanelFfsTabCenter.setLayout(new BorderLayout());
485 jPanelFfsTabCenter.add(getJPanelFfsTabCenterN(), java.awt.BorderLayout.NORTH);
486 jPanelFfsTabCenter.add(getJPanelFfsTabCenterS(), java.awt.BorderLayout.SOUTH);
487 jPanelFfsTabCenter.add(getJSplitPaneFfsC(), java.awt.BorderLayout.CENTER);
488 }
489 return jPanelFfsTabCenter;
490 }
491
492 /**
493 * This method initializes jPanel15
494 *
495 * @return javax.swing.JPanel
496 */
497 private JPanel getJPanelFfsTabCenterN() {
498 if (jPanelFfsTabCenterN == null) {
499 jLabelEncapType = new JLabel();
500 jLabelEncapType.setText("Encapsulation Type");
501 FlowLayout flowLayout5 = new FlowLayout();
502 flowLayout5.setAlignment(java.awt.FlowLayout.RIGHT);
503 jLabelFfsKey = new JLabel();
504 jLabelFfsKey.setText("FFS Key");
505 jPanelFfsTabCenterN = new JPanel();
506 jPanelFfsTabCenterN.setLayout(flowLayout5);
507 jPanelFfsTabCenterN.add(jLabelFfsKey, null);
508 jPanelFfsTabCenterN.add(getJTextFieldFfsKey(), null);
509 jPanelFfsTabCenterN.add(jLabelEncapType, null);
510 jPanelFfsTabCenterN.add(getJTextFieldEncapType(), null);
511 jPanelFfsTabCenterN.add(getJButtonFfsAdd(), null);
512 jPanelFfsTabCenterN.add(getJButtonFfsDel(), null);
513 }
514 return jPanelFfsTabCenterN;
515 }
516
517 /**
518 * This method initializes jPanel16
519 *
520 * @return javax.swing.JPanel
521 */
522 private JPanel getJPanelFfsTabCenterS() {
523 if (jPanelFfsTabCenterS == null) {
524 jLabelFfsAttribs = new JLabel();
525 jLabelFfsAttribs.setText("Attributes");
526 FlowLayout flowLayout6 = new FlowLayout();
527 flowLayout6.setHgap(5);
528 flowLayout6.setVgap(20);
529 flowLayout6.setAlignment(java.awt.FlowLayout.CENTER);
530 jPanelFfsTabCenterS = new JPanel();
531 jPanelFfsTabCenterS.setPreferredSize(new java.awt.Dimension(491, 130));
532 jPanelFfsTabCenterS.setLayout(flowLayout6);
533 jPanelFfsTabCenterS.add(jLabelFfsAttribs, null);
534 jPanelFfsTabCenterS.add(getJScrollPaneFfsAttribs(), null);
535 jPanelFfsTabCenterS.add(getJPanelFfsAttribButtonGroup(), null);
536 }
537 return jPanelFfsTabCenterS;
538 }
539
540 /**
541 * This method initializes jTextField6
542 *
543 * @return javax.swing.JTextField
544 */
545 private JTextField getJTextFieldFfsKey() {
546 if (jTextFieldFfsKey == null) {
547 jTextFieldFfsKey = new JTextField();
548 jTextFieldFfsKey.setPreferredSize(new java.awt.Dimension(100, 20));
549 jTextFieldFfsKey.setEditable(true);
550 jTextFieldFfsKey.addFocusListener(new java.awt.event.FocusAdapter() {
551 public void focusLost(java.awt.event.FocusEvent e) {
552 if (jTableFfs.getSelectedRow() < 0) {
553 return;
554 }
555 // ffc.updateBuildOptionsFfsKey(jTable.getSelectedRow(), jTextField6.getText());
556 }
557 });
558 }
559 return jTextFieldFfsKey;
560 }
561
562 /**
563 * This method initializes jButton8
564 *
565 * @return javax.swing.JButton
566 */
567 private JButton getJButtonFfsAdd() {
568 if (jButtonFfsAdd == null) {
569 jButtonFfsAdd = new JButton();
570 jButtonFfsAdd.setPreferredSize(new java.awt.Dimension(70, 20));
571 jButtonFfsAdd.setText("Add");
572 jButtonFfsAdd.addActionListener(new AbstractAction() {
573 /**
574 *
575 */
576 private static final long serialVersionUID = -2923720717273384221L;
577
578 public void actionPerformed(java.awt.event.ActionEvent e) {
579 if (jTextFieldFfsKey.getText().length() > 0) {
580 String[] row = { jTextFieldFfsKey.getText() };
581 ffsTableModel.addRow(row);
582 docConsole.setSaved(false);
583 ffc.genBuildOptionsFfs(jTextFieldFfsKey.getText(), jTextFieldEncapType.getText());
584 }
585 }
586 });
587 }
588 return jButtonFfsAdd;
589 }
590
591 /**
592 * This method initializes jButton9
593 *
594 * @return javax.swing.JButton
595 */
596 private JButton getJButtonFfsDel() {
597 if (jButtonFfsDel == null) {
598 jButtonFfsDel = new JButton();
599 jButtonFfsDel.setPreferredSize(new java.awt.Dimension(70, 20));
600 jButtonFfsDel.setText("Delete");
601 jButtonFfsDel.addActionListener(new AbstractAction() {
602 /**
603 *
604 */
605 private static final long serialVersionUID = -4002678939178194476L;
606
607 public void actionPerformed(ActionEvent arg0) {
608 if (jTableFfs.getSelectedRow() < 0) {
609 return;
610 }
611 docConsole.setSaved(false);
612 ffc.removeBuildOptionsFfs(jTableFfs.getSelectedRow());
613 ffsTableModel.removeRow(jTableFfs.getSelectedRow());
614 }
615 });
616 }
617 return jButtonFfsDel;
618 }
619
620 /**
621 * This method initializes jScrollPane5
622 *
623 * @return javax.swing.JScrollPane
624 */
625 private JScrollPane getJScrollPaneFfsAttribs() {
626 if (jScrollPaneFfsAttribs == null) {
627 jScrollPaneFfsAttribs = new JScrollPane();
628 jScrollPaneFfsAttribs.setPreferredSize(new java.awt.Dimension(350, 100));
629 jScrollPaneFfsAttribs.setViewportView(getJTableFfsAttribs());
630 }
631 return jScrollPaneFfsAttribs;
632 }
633
634 /**
635 * This method initializes jTable4
636 *
637 * @return javax.swing.JTable
638 */
639 private JTable getJTableFfsAttribs() {
640 if (jTableFfsAttribs == null) {
641 ffsAttributesTableModel = new DefaultTableModel();
642 jTableFfsAttribs = new JTable(ffsAttributesTableModel);
643 jTableFfsAttribs.setPreferredSize(new java.awt.Dimension(400, 80));
644 jTableFfsAttribs.setRowHeight(20);
645 ffsAttributesTableModel.addColumn("Name");
646 ffsAttributesTableModel.addColumn("Value");
647
648 jTableFfsAttribs.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
649 jTableFfsAttribs.getModel().addTableModelListener(new TableModelListener() {
650 public void tableChanged(TableModelEvent arg0) {
651 // TODO Auto-generated method stub
652 int row = arg0.getFirstRow();
653 TableModel m = (TableModel) arg0.getSource();
654 if (arg0.getType() == TableModelEvent.UPDATE) {
655 //ToDo Data Validition check.
656 String name = m.getValueAt(row, 0) + "";
657 String value = m.getValueAt(row, 1) + "";
658
659 if (name.length() == 0) {
660 return;
661 }
662 if (value.length() == 0) {
663 return;
664 }
665 docConsole.setSaved(false);
666 ffc.updateBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(), row, name, value);
667 }
668 }
669 });
670 }
671 return jTableFfsAttribs;
672 }
673
674 private void initFfsTable() {
675 int ffsCount = ffc.getBuildOptionsFfsCount();
676 if (ffsCount < 0) {
677 return;
678 }
679 String[][] saa = new String[ffsCount][1];
680 ffc.getBuildOptionsFfsKey(saa);
681 for (int i = 0; i < saa.length; ++i) {
682 ffsTableModel.addRow(saa[i]);
683 }
684 }
685
686 /**
687 * This method initializes jButton17
688 *
689 * @return javax.swing.JButton
690 */
691 private JButton getJButtonFfsAttribNew() {
692 if (jButtonFfsAttribNew == null) {
693 jButtonFfsAttribNew = new JButton();
694 jButtonFfsAttribNew.setPreferredSize(new java.awt.Dimension(80, 20));
695 jButtonFfsAttribNew.setText("New");
696 jButtonFfsAttribNew.addActionListener(new AbstractAction() {
697 /**
698 *
699 */
700 private static final long serialVersionUID = 1L;
701
702 public void actionPerformed(ActionEvent arg0) {
703 if (jTableFfs.getSelectedRow() < 0) {
704 return;
705 }
706 Object[] o = { "", "" };
707 ffsAttributesTableModel.addRow(o);
708 docConsole.setSaved(false);
709 ffc.genBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(), "", "");
710 }
711 });
712 }
713 return jButtonFfsAttribNew;
714 }
715
716 /**
717 * This method initializes jButton18
718 *
719 * @return javax.swing.JButton
720 */
721 private JButton getJButtonFfsAttribRemove() {
722 if (jButtonFfsAttribRemove == null) {
723 jButtonFfsAttribRemove = new JButton();
724 jButtonFfsAttribRemove.setPreferredSize(new java.awt.Dimension(80, 20));
725 jButtonFfsAttribRemove.setText("Remove");
726 jButtonFfsAttribRemove.addActionListener(new AbstractAction() {
727 /**
728 *
729 */
730 private static final long serialVersionUID = 1L;
731
732 public void actionPerformed(ActionEvent arg0) {
733 if (jTableFfs.getSelectedRow() < 0) {
734 return;
735 }
736 if (jTableFfsAttribs.getSelectedRow() >= 0) {
737 docConsole.setSaved(false);
738 ffsAttributesTableModel.removeRow(jTableFfsAttribs.getSelectedRow());
739 ffc.removeBuildOptionsFfsAttribute(jTableFfs.getSelectedRow(),
740 jTableFfsAttribs.getSelectedRow());
741 }
742 }
743 });
744 }
745 return jButtonFfsAttribRemove;
746 }
747
748 /**
749 * This method initializes jScrollPane
750 *
751 * @return javax.swing.JScrollPane
752 */
753 private JScrollPane getJScrollPaneFfs() {
754 if (jScrollPaneFfs == null) {
755 jScrollPaneFfs = new JScrollPane();
756 jScrollPaneFfs.setPreferredSize(new java.awt.Dimension(150, 419));
757 jScrollPaneFfs.setViewportView(getJTableFfs());
758 }
759 return jScrollPaneFfs;
760 }
761
762 /**
763 * This method initializes jTable
764 *
765 * @return javax.swing.JTable
766 */
767 private JTable getJTableFfs() {
768 if (jTableFfs == null) {
769 ffsTableModel = new DefaultTableModel();
770 ffsTableModel.addColumn("FFS Type");
771 jTableFfs = new JTable(ffsTableModel);
772 jTableFfs.setShowGrid(false);
773 jTableFfs.setRowHeight(20);
774
775 jTableFfs.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
776 jTableFfs.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
777 public void valueChanged(ListSelectionEvent e) {
778
779 if (e.getValueIsAdjusting()) {
780 return;
781 }
782 ListSelectionModel lsm = (ListSelectionModel) e.getSource();
783 if (lsm.isSelectionEmpty()) {
784 return;
785 } else {
786 int row = lsm.getMinSelectionIndex();
787 sectionTableModel.setRowCount(0);
788 sectionsTableModel.setRowCount(0);
789 subsectionsTableModel.setRowCount(0);
790 ffsAttributesTableModel.setRowCount(0);
791 String[] sArray = { "", "" };
792 LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
793 ArrayList<String> alSections = new ArrayList<String>();
794 ArrayList<String> alSection = new ArrayList<String>();
795 ffc.getBuildOptionsFfs(row, sArray, lhm, alSections, alSection);
796 jTextFieldFfsKey.setText(sArray[0]);
797 jTextFieldEncapType.setText(sArray[1]);
798 for (int i = 0; i < alSection.size(); ++i) {
799 String[] sectionRow = { alSection.get(i) };
800 sectionTableModel.addRow(sectionRow);
801 }
802 for (int j = 0; j < alSections.size(); ++j) {
803 String[] sectionsRow = { alSections.get(j) };
804 sectionsTableModel.addRow(sectionsRow);
805 }
806 if (lhm.size() <= 0) {
807 return;
808 }
809 Set<String> keySet = lhm.keySet();
810 Iterator<String> is = keySet.iterator();
811 while (is.hasNext()) {
812 String key = is.next();
813 String[] attribRow = { key, lhm.get(key) };
814 ffsAttributesTableModel.addRow(attribRow);
815 }
816 }
817 }
818 });
819
820 jTableFfs.getModel().addTableModelListener(new TableModelListener() {
821 public void tableChanged(TableModelEvent arg0) {
822 // TODO Auto-generated method stub
823 int row = arg0.getFirstRow();
824 TableModel m = (TableModel) arg0.getSource();
825 if (arg0.getType() == TableModelEvent.UPDATE) {
826 //ToDo Data Validition check.
827 String id = m.getValueAt(row, 0) + "";
828
829 if (id.length() == 0) {
830 return;
831 }
832 docConsole.setSaved(false);
833 ffc.updateBuildOptionsFfsKey(row, id);
834 }
835 }
836 });
837 }
838 return jTableFfs;
839 }
840
841 /**
842 * This method initializes jScrollPane1
843 *
844 * @return javax.swing.JScrollPane
845 */
846 private JScrollPane getJScrollPaneFfsSection() {
847 if (jScrollPaneFfsSection == null) {
848 jScrollPaneFfsSection = new JScrollPane();
849 // jScrollPaneFfsSection.setPreferredSize(new java.awt.Dimension(500, 80));
850 jScrollPaneFfsSection.setViewportView(getJTableFfsSection());
851 }
852 return jScrollPaneFfsSection;
853 }
854
855 /**
856 * This method initializes jTable1
857 *
858 * @return javax.swing.JTable
859 */
860 private JTable getJTableFfsSection() {
861 if (jTableFfsSection == null) {
862 sectionTableModel = new DefaultTableModel();
863 sectionTableModel.addColumn("SectionType");
864
865 jTableFfsSection = new JTable(sectionTableModel);
866 jTableFfsSection.setRowHeight(20);
867 JComboBox cb = new JComboBox();
868 cb.addItem("EFI_SECTION_FREEFORM_SUBTYPE_GUID");
869 cb.addItem("EFI_SECTION_VERSION");
870 cb.addItem("EFI_SECTION_USER_INTERFACE");
871 cb.addItem("EFI_SECTION_DXE_DEPEX");
872 cb.addItem("EFI_SECTION_PEI_DEPEX");
873 cb.addItem("EFI_SECTION_PE32");
874 cb.addItem("EFI_SECTION_PIC");
875 cb.addItem("EFI_SECTION_TE");
876 cb.addItem("EFI_SECTION_RAW");
877 cb.addItem("EFI_SECTION_COMPRESSION");
878 cb.addItem("EFI_SECTION_GUID_DEFINED");
879 cb.addItem("EFI_SECTION_COMPATIBILITY16");
880 cb.addItem("EFI_SECTION_FIRMWARE_VOLUME_IMAGE");
881 jTableFfsSection.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(cb));
882
883 jTableFfsSection.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
884
885 jTableFfsSection.getModel().addTableModelListener(new TableModelListener() {
886 public void tableChanged(TableModelEvent arg0) {
887 // TODO Auto-generated method stub
888 if (jTableFfs.getSelectedRow() < 0) {
889 return;
890 }
891 int row = arg0.getFirstRow();
892 TableModel m = (TableModel) arg0.getSource();
893 if (arg0.getType() == TableModelEvent.UPDATE) {
894 //ToDo Data Validition check.
895 String type = m.getValueAt(row, 0) + "";
896 docConsole.setSaved(false);
897 ffc.updateBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(), row, type);
898 }
899 }
900 });
901 }
902 return jTableFfsSection;
903 }
904
905 /**
906 * This method initializes jScrollPane3
907 *
908 * @return javax.swing.JScrollPane
909 */
910 private JScrollPane getJScrollPaneFfsSubSection() {
911 if (jScrollPaneFfsSubSection == null) {
912 jScrollPaneFfsSubSection = new JScrollPane();
913 // jScrollPaneFfsSubSection.setPreferredSize(new java.awt.Dimension(500, 90));
914 jScrollPaneFfsSubSection.setViewportView(getJTableFfsSubSection());
915 }
916 return jScrollPaneFfsSubSection;
917 }
918
919 /**
920 * This method initializes jTable3
921 *
922 * @return javax.swing.JTable
923 */
924 private JTable getJTableFfsSubSection() {
925 if (jTableFfsSubSection == null) {
926 subsectionsTableModel = new DefaultTableModel();
927 subsectionsTableModel.addColumn("SectionType");
928 jTableFfsSubSection = new JTable(subsectionsTableModel);
929 jTableFfsSubSection.setRowHeight(20);
930 JComboBox cb = new JComboBox();
931 cb.addItem("EFI_SECTION_FREEFORM_SUBTYPE_GUID");
932 cb.addItem("EFI_SECTION_VERSION");
933 cb.addItem("EFI_SECTION_USER_INTERFACE");
934 cb.addItem("EFI_SECTION_DXE_DEPEX");
935 cb.addItem("EFI_SECTION_PEI_DEPEX");
936 cb.addItem("EFI_SECTION_PE32");
937 cb.addItem("EFI_SECTION_PIC");
938 cb.addItem("EFI_SECTION_TE");
939 cb.addItem("EFI_SECTION_RAW");
940 cb.addItem("EFI_SECTION_COMPRESSION");
941 cb.addItem("EFI_SECTION_GUID_DEFINED");
942 cb.addItem("EFI_SECTION_COMPATIBILITY16");
943 cb.addItem("EFI_SECTION_FIRMWARE_VOLUME_IMAGE");
944 jTableFfsSubSection.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(cb));
945 jTableFfsSubSection.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
946
947 jTableFfsSubSection.getModel().addTableModelListener(new TableModelListener() {
948 public void tableChanged(TableModelEvent arg0) {
949 // TODO Auto-generated method stub
950 if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) {
951 return;
952 }
953 int row = arg0.getFirstRow();
954 TableModel m = (TableModel) arg0.getSource();
955 if (arg0.getType() == TableModelEvent.UPDATE) {
956 //ToDo Data Validition check.
957 String type = m.getValueAt(row, 0) + "";
958 docConsole.setSaved(false);
959 ffc.updateBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(),
960 jTableFfsSections.getSelectedRow(), row, type);
961 }
962 }
963 });
964 }
965 return jTableFfsSubSection;
966 }
967
968 /**
969 * This method initializes jTextField
970 *
971 * @return javax.swing.JTextField
972 */
973 private JTextField getJTextFieldEncapType() {
974 if (jTextFieldEncapType == null) {
975 jTextFieldEncapType = new JTextField();
976 jTextFieldEncapType.setPreferredSize(new java.awt.Dimension(100, 20));
977 jTextFieldEncapType.addFocusListener(new java.awt.event.FocusAdapter() {
978 public void focusLost(java.awt.event.FocusEvent e) {
979 if (jTableFfs.getSelectedRow() < 0) {
980 return;
981 }
982 ffc.updateBuildOptionsFfsSectionsType(jTableFfs.getSelectedRow(), jTextFieldEncapType.getText());
983 }
984 });
985 }
986 return jTextFieldEncapType;
987 }
988
989 /**
990 * This method initializes jPanel4
991 *
992 * @return javax.swing.JPanel
993 */
994 private JPanel getJPanelFfsAttribButtonGroup() {
995 if (jPanelFfsAttribButtonGroup == null) {
996 jPanelFfsAttribButtonGroup = new JPanel();
997 jPanelFfsAttribButtonGroup.setPreferredSize(new java.awt.Dimension(100, 100));
998 jPanelFfsAttribButtonGroup.add(getJButtonFfsAttribNew(), null);
999 jPanelFfsAttribButtonGroup.add(getJButtonFfsAttribRemove(), null);
1000 }
1001 return jPanelFfsAttribButtonGroup;
1002 }
1003
1004 /**
1005 * This method initializes jButton
1006 *
1007 * @return javax.swing.JButton
1008 */
1009 private JButton getJButtonFfsSectionNew() {
1010 if (jButtonFfsSectionNew == null) {
1011 jButtonFfsSectionNew = new JButton();
1012 jButtonFfsSectionNew.setPreferredSize(new java.awt.Dimension(80, 20));
1013 jButtonFfsSectionNew.setText("New");
1014 jButtonFfsSectionNew.addActionListener(new java.awt.event.ActionListener() {
1015 public void actionPerformed(java.awt.event.ActionEvent e) {
1016 if (jTableFfs.getSelectedRow() < 0) {
1017 return;
1018 }
1019 docConsole.setSaved(false);
1020 String[] row = { "EFI_SECTION_RAW" };
1021 sectionTableModel.addRow(row);
1022 ffc.genBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(), row[0]);
1023 }
1024 });
1025 }
1026 return jButtonFfsSectionNew;
1027 }
1028
1029 /**
1030 * This method initializes jButton1
1031 *
1032 * @return javax.swing.JButton
1033 */
1034 private JButton getJButtonFfsSectionRemove() {
1035 if (jButtonFfsSectionRemove == null) {
1036 jButtonFfsSectionRemove = new JButton();
1037 jButtonFfsSectionRemove.setPreferredSize(new java.awt.Dimension(80, 20));
1038 jButtonFfsSectionRemove.setText("Remove");
1039
1040 jButtonFfsSectionRemove.addActionListener(new java.awt.event.ActionListener() {
1041 public void actionPerformed(java.awt.event.ActionEvent e) {
1042 if (jTableFfs.getSelectedRow() < 0 || jTableFfsSection.getSelectedRow() < 0) {
1043 return;
1044 }
1045 docConsole.setSaved(false);
1046 sectionTableModel.removeRow(jTableFfsSection.getSelectedRow());
1047 ffc.removeBuildOptionsFfsSectionsSection(jTableFfs.getSelectedRow(),
1048 jTableFfsSection.getSelectedRow());
1049 }
1050 });
1051 }
1052 return jButtonFfsSectionRemove;
1053 }
1054
1055 /**
1056 * This method initializes jButton2
1057 *
1058 * @return javax.swing.JButton
1059 */
1060 private JButton getJButtonFfsSubSectionNew() {
1061 if (jButtonFfsSubSectionNew == null) {
1062 jButtonFfsSubSectionNew = new JButton();
1063 jButtonFfsSubSectionNew.setPreferredSize(new java.awt.Dimension(80, 20));
1064 jButtonFfsSubSectionNew.setText("New");
1065 jButtonFfsSubSectionNew.addActionListener(new java.awt.event.ActionListener() {
1066 public void actionPerformed(java.awt.event.ActionEvent e) {
1067 if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) {
1068 return;
1069 }
1070 docConsole.setSaved(false);
1071 String[] row = { "EFI_SECTION_RAW" };
1072 subsectionsTableModel.addRow(row);
1073 ffc.genBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(),
1074 jTableFfsSections.getSelectedRow(), row[0]);
1075
1076 }
1077 });
1078 }
1079 return jButtonFfsSubSectionNew;
1080 }
1081
1082 /**
1083 * This method initializes jButton3
1084 *
1085 * @return javax.swing.JButton
1086 */
1087 private JButton getJButtonFfsSubSectionRemove() {
1088 if (jButtonFfsSubSectionRemove == null) {
1089 jButtonFfsSubSectionRemove = new JButton();
1090 jButtonFfsSubSectionRemove.setPreferredSize(new java.awt.Dimension(80, 20));
1091 jButtonFfsSubSectionRemove.setText("Remove");
1092 jButtonFfsSubSectionRemove.addActionListener(new java.awt.event.ActionListener() {
1093 public void actionPerformed(java.awt.event.ActionEvent e) {
1094 if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0
1095 || jTableFfsSubSection.getSelectedRow() < 0) {
1096 return;
1097 }
1098 docConsole.setSaved(false);
1099 subsectionsTableModel.removeRow(jTableFfsSubSection.getSelectedRow());
1100 ffc.removeBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(),
1101 jTableFfsSections.getSelectedRow(),
1102 jTableFfsSubSection.getSelectedRow());
1103 }
1104 });
1105 }
1106 return jButtonFfsSubSectionRemove;
1107 }
1108
1109 /**
1110 * This method initializes jButton6
1111 *
1112 * @return javax.swing.JButton
1113 */
1114 private JButton getJButtonFfsSectionsNew() {
1115 if (jButtonFfsSectionsNew == null) {
1116 jButtonFfsSectionsNew = new JButton();
1117 jButtonFfsSectionsNew.setPreferredSize(new java.awt.Dimension(80, 20));
1118 jButtonFfsSectionsNew.setText("New");
1119 jButtonFfsSectionsNew.addActionListener(new java.awt.event.ActionListener() {
1120 public void actionPerformed(java.awt.event.ActionEvent e) {
1121 if (jTableFfs.getSelectedRow() < 0) {
1122 return;
1123 }
1124 docConsole.setSaved(false);
1125 String[] row = { "" };
1126 sectionsTableModel.addRow(row);
1127 ffc.genBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), "");
1128 }
1129 });
1130 }
1131 return jButtonFfsSectionsNew;
1132 }
1133
1134 /**
1135 * This method initializes jButton7
1136 *
1137 * @return javax.swing.JButton
1138 */
1139 private JButton getJButtonFfsSectionsRemove() {
1140 if (jButtonFfsSectionsRemove == null) {
1141 jButtonFfsSectionsRemove = new JButton();
1142 jButtonFfsSectionsRemove.setPreferredSize(new java.awt.Dimension(80, 20));
1143 jButtonFfsSectionsRemove.setText("Remove");
1144 jButtonFfsSectionsRemove.addActionListener(new java.awt.event.ActionListener() {
1145 public void actionPerformed(java.awt.event.ActionEvent e) {
1146 if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) {
1147 return;
1148 }
1149 docConsole.setSaved(false);
1150 sectionsTableModel.removeRow(jTableFfsSections.getSelectedRow());
1151 ffc.removeBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(),
1152 jTableFfsSections.getSelectedRow());
1153 }
1154 });
1155 }
1156 return jButtonFfsSectionsRemove;
1157 }
1158
1159 private JScrollPane getJScrollPaneFfsSections() {
1160 if (jScrollPaneFfsSections == null) {
1161 jScrollPaneFfsSections = new JScrollPane();
1162 // jScrollPaneFfsSections.setPreferredSize(new java.awt.Dimension(500, 80));
1163 jScrollPaneFfsSections.setViewportView(getJTableFfsSections());
1164 }
1165 return jScrollPaneFfsSections;
1166 }
1167
1168 /**
1169 * This method initializes jTable6
1170 *
1171 * @return javax.swing.JTable
1172 */
1173 private JTable getJTableFfsSections() {
1174 if (jTableFfsSections == null) {
1175 sectionsTableModel = new DefaultTableModel();
1176 sectionsTableModel.addColumn("EncapsulationType");
1177 jTableFfsSections = new JTable(sectionsTableModel);
1178 jTableFfsSections.setRowHeight(20);
1179 jTableFfsSections.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1180 jTableFfsSections.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
1181 public void valueChanged(ListSelectionEvent e) {
1182 if (e.getValueIsAdjusting()) {
1183 return;
1184 }
1185 ListSelectionModel lsm = (ListSelectionModel) e.getSource();
1186 if (lsm.isSelectionEmpty()) {
1187 return;
1188 } else {
1189 int sectionsRow = lsm.getMinSelectionIndex();
1190 if (jTableFfs.getSelectedRow() < 0) {
1191 return;
1192 }
1193 subsectionsTableModel.setRowCount(0);
1194 ArrayList<String> al = new ArrayList<String>();
1195 ffc.getBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(), sectionsRow, al);
1196 for (int i = 0; i < al.size(); ++i) {
1197 String[] subsectionRow = { al.get(i) };
1198 subsectionsTableModel.addRow(subsectionRow);
1199 }
1200 }
1201 }
1202 });
1203
1204 jTableFfsSections.getModel().addTableModelListener(new TableModelListener() {
1205 public void tableChanged(TableModelEvent arg0) {
1206 // TODO Auto-generated method stub
1207 int row = arg0.getFirstRow();
1208 TableModel m = (TableModel) arg0.getSource();
1209 if (arg0.getType() == TableModelEvent.UPDATE) {
1210 //ToDo Data Validition check.
1211 String encapType = m.getValueAt(row, 0) + "";
1212 docConsole.setSaved(false);
1213 ffc.updateBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), row, encapType);
1214 }
1215 }
1216 });
1217 }
1218 return jTableFfsSections;
1219 }
1220
1221 /**
1222 * This method initializes jSplitPaneFfsC
1223 *
1224 * @return javax.swing.JSplitPane
1225 */
1226 private JSplitPane getJSplitPaneFfsC() {
1227 if (jSplitPaneFfsC == null) {
1228 jSplitPaneFfsC = new JSplitPane();
1229 jSplitPaneFfsC.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1230 jSplitPaneFfsC.setDividerLocation(130);
1231 jSplitPaneFfsC.setTopComponent(getJPanelFfsCTop());
1232 jSplitPaneFfsC.setBottomComponent(getJSplitPaneFfsCBottom());
1233 jSplitPaneFfsC.setDividerSize(5);
1234 }
1235 return jSplitPaneFfsC;
1236 }
1237
1238 /**
1239 * This method initializes jPanelFfsCTop
1240 *
1241 * @return javax.swing.JPanel
1242 */
1243 private JPanel getJPanelFfsCTop() {
1244 if (jPanelFfsCTop == null) {
1245 jPanelFfsCTop = new JPanel();
1246 jPanelFfsCTop.setLayout(new BorderLayout());
1247 jPanelFfsCTop.add(getJPanelSectionN(), java.awt.BorderLayout.NORTH);
1248 jPanelFfsCTop.add(getJPanelSectionC(), java.awt.BorderLayout.CENTER);
1249 }
1250 return jPanelFfsCTop;
1251 }
1252
1253 /**
1254 * This method initializes jSplitPaneFfsCBottom
1255 *
1256 * @return javax.swing.JSplitPane
1257 */
1258 private JSplitPane getJSplitPaneFfsCBottom() {
1259 if (jSplitPaneFfsCBottom == null) {
1260 jSplitPaneFfsCBottom = new JSplitPane();
1261 jSplitPaneFfsCBottom.setDividerSize(5);
1262 jSplitPaneFfsCBottom.setDividerLocation(130);
1263 jSplitPaneFfsCBottom.setTopComponent(getJPanelFfsCBottomTop());
1264 jSplitPaneFfsCBottom.setBottomComponent(getJPanelFfsCBottomBottom());
1265 jSplitPaneFfsCBottom.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1266 }
1267 return jSplitPaneFfsCBottom;
1268 }
1269
1270 /**
1271 * This method initializes jPanelFfsCBottomTop
1272 *
1273 * @return javax.swing.JPanel
1274 */
1275 private JPanel getJPanelFfsCBottomTop() {
1276 if (jPanelFfsCBottomTop == null) {
1277 jPanelFfsCBottomTop = new JPanel();
1278 jPanelFfsCBottomTop.setLayout(new BorderLayout());
1279 jPanelFfsCBottomTop.add(getJPanelSectionsN(), java.awt.BorderLayout.NORTH);
1280 jPanelFfsCBottomTop.add(getJPanelSectionsC(), java.awt.BorderLayout.CENTER);
1281 }
1282 return jPanelFfsCBottomTop;
1283 }
1284
1285 /**
1286 * This method initializes jPanelFfsCBottomBottom
1287 *
1288 * @return javax.swing.JPanel
1289 */
1290 private JPanel getJPanelFfsCBottomBottom() {
1291 if (jPanelFfsCBottomBottom == null) {
1292 jPanelFfsCBottomBottom = new JPanel();
1293 jPanelFfsCBottomBottom.setLayout(new BorderLayout());
1294 jPanelFfsCBottomBottom.add(getJPanelSubSectionN(), java.awt.BorderLayout.NORTH);
1295 jPanelFfsCBottomBottom.add(getJPanelSubSectionC(), java.awt.BorderLayout.CENTER);
1296 }
1297 return jPanelFfsCBottomBottom;
1298 }
1299
1300 /**
1301 * This method initializes jPanelSectionN
1302 *
1303 * @return javax.swing.JPanel
1304 */
1305 private JPanel getJPanelSectionN() {
1306 if (jPanelSectionN == null) {
1307 jPanelSectionN = new JPanel();
1308 jLabelFfsSection = new JLabel();
1309 jLabelFfsSection.setText("Section");
1310 jPanelSectionN.add(jLabelFfsSection, null);
1311 jPanelSectionN.add(getJButtonFfsSectionNew(), null);
1312 jPanelSectionN.add(getJButtonFfsSectionRemove(), null);
1313 }
1314 return jPanelSectionN;
1315 }
1316
1317 /**
1318 * This method initializes jPanelSectionC
1319 *
1320 * @return javax.swing.JPanel
1321 */
1322 private JPanel getJPanelSectionC() {
1323 if (jPanelSectionC == null) {
1324 jPanelSectionC = new JPanel();
1325 jPanelSectionC.add(getJScrollPaneFfsSection(), null);
1326 }
1327 return jPanelSectionC;
1328 }
1329
1330 /**
1331 * This method initializes jPanelSectionsN
1332 *
1333 * @return javax.swing.JPanel
1334 */
1335 private JPanel getJPanelSectionsN() {
1336 if (jPanelSectionsN == null) {
1337 jPanelSectionsN = new JPanel();
1338 jLabelFfsSections = new JLabel();
1339 jLabelFfsSections.setText("Sections");
1340 jPanelSectionsN.add(jLabelFfsSections, null);
1341 jPanelSectionsN.add(getJButtonFfsSectionsNew(), null);
1342 jPanelSectionsN.add(getJButtonFfsSectionsRemove(), null);
1343 }
1344 return jPanelSectionsN;
1345 }
1346
1347 /**
1348 * This method initializes jPanelSectionsC
1349 *
1350 * @return javax.swing.JPanel
1351 */
1352 private JPanel getJPanelSectionsC() {
1353 if (jPanelSectionsC == null) {
1354 jPanelSectionsC = new JPanel();
1355 jPanelSectionsC.add(getJScrollPaneFfsSections(), null);
1356 }
1357 return jPanelSectionsC;
1358 }
1359
1360 /**
1361 * This method initializes jPanelSubSectionN
1362 *
1363 * @return javax.swing.JPanel
1364 */
1365 private JPanel getJPanelSubSectionN() {
1366 if (jPanelSubSectionN == null) {
1367 jPanelSubSectionN = new JPanel();
1368 jLabelFfsSubSections = new JLabel();
1369 jLabelFfsSubSections.setText("Sub-Sections");
1370 jPanelSubSectionN.add(jLabelFfsSubSections, null);
1371 jPanelSubSectionN.add(getJButtonFfsSubSectionNew(), null);
1372 jPanelSubSectionN.add(getJButtonFfsSubSectionRemove(), null);
1373 }
1374 return jPanelSubSectionN;
1375 }
1376
1377 /**
1378 * This method initializes jPanelSubSectionC
1379 *
1380 * @return javax.swing.JPanel
1381 */
1382 private JPanel getJPanelSubSectionC() {
1383 if (jPanelSubSectionC == null) {
1384 jPanelSubSectionC = new JPanel();
1385 jPanelSubSectionC.add(getJScrollPaneFfsSubSection(), null);
1386 }
1387 return jPanelSubSectionC;
1388 }
1389
1390 /**
1391 * The following section contains all Build Options content
1392 */
1393
1394 /**
1395 * This method initializes jPanelOptionsTab
1396 *
1397 * This is the main Options screen
1398 *
1399 * @return javax.swing.JPanel jPanelOptionsTab
1400 */
1401 private JPanel getJPanelOptionsTab() {
1402 if (jPanelOptionsTab == null) {
1403 // This container holds the Options Tab content
1404
1405 // FlowLayout flowLayout9 = new FlowLayout();
1406 // flowLayout9.setAlignment(java.awt.FlowLayout.LEFT);
1407
1408 jPanelOptionsTab = new JPanel();
1409 jPanelOptionsTab.setBounds(new java.awt.Rectangle(0, 0, dialogWidth * 2, dialogHeight * 3));
1410 jPanelOptionsTab.setPreferredSize(new java.awt.Dimension(dialogWidth + 10, (dialogHeight * 3) + 10));
1411 jPanelOptionsTab.setAutoscrolls(true);
1412 jPanelOptionsTab.setLocation(0, 0);
1413 jPanelOptionsTab.setLayout(null);
1414 jPanelOptionsTab.add(getJPanelOptionsContainer(), null);
1415 jPanelOptionsTab.add(getJScrollPaneOptions(), null);
1416
1417 }
1418 return jPanelOptionsTab;
1419 }
1420
1421 /**
1422 * This method initializes jPanelOptionsContainer
1423 *
1424 * @return javax.swing.JPanel
1425 */
1426 private JPanel getJPanelOptionsContainer() {
1427 if (jPanelOptionsContainer == null) {
1428 jLabelTagName = new JLabel();
1429 jLabelTagName.setBounds(new java.awt.Rectangle(labelColumn, rowOne, labelWidth, oneRowHeight));
1430 jLabelTagName.setLocation(new java.awt.Point(labelColumn, rowOne));
1431 jLabelTagName.setText("Tag Name");
1432 jLabelBuildTargets = new JLabel();
1433 jLabelBuildTargets.setBounds(new java.awt.Rectangle(labelColumn, rowTwo, labelWidth, oneRowHeight));
1434 jLabelBuildTargets.setLocation(new java.awt.Point(labelColumn, rowTwo));
1435 jLabelBuildTargets.setText("Build Targets");
1436 jLabelToolCmd = new JLabel();
1437 jLabelToolCmd.setBounds(new java.awt.Rectangle(labelColumn, rowThree, labelWidth, oneRowHeight));
1438 jLabelToolCmd.setLocation(new java.awt.Point(labelColumn, rowThree));
1439 jLabelToolCmd.setText("Tool Command");
1440 jLabelSupArch = new JLabel();
1441 jLabelSupArch.setBounds(new java.awt.Rectangle(labelColumn, rowFour, labelWidth, oneRowHeight));
1442 jLabelSupArch.setLocation(new java.awt.Point(labelColumn, rowFour));
1443 jLabelSupArch.setText("Supported Architectures");
1444 jLabelToolChainFamily = new JLabel();
1445 jLabelToolChainFamily.setBounds(new java.awt.Rectangle(labelColumn, rowFive, labelWidth, oneRowHeight));
1446 jLabelToolChainFamily.setLocation(new java.awt.Point(labelColumn, rowFive));
1447 jLabelToolChainFamily.setText("Tool Chain Family");
1448
1449 jLabelOptionContents = new JLabel();
1450 jLabelOptionContents.setBounds(new java.awt.Rectangle(labelColumn, rowSix, labelWidth, oneRowHeight));
1451 jLabelOptionContents.setLocation(new java.awt.Point(labelColumn, rowSix));
1452 jLabelOptionContents.setText("Option Contents");
1453
1454 jPanelOptionsContainer = new JPanel();
1455
1456 jPanelOptionsContainer.setLayout(null);
1457
1458 jPanelOptionsContainer.setLocation(new java.awt.Point(2, 2));
1459 jPanelOptionsContainer.setBounds(new java.awt.Rectangle(2, 2, dialogWidth * 2, dialogHeight));
1460 jPanelOptionsContainer.setPreferredSize(new java.awt.Dimension(dialogWidth, dialogHeight));
1461 /*
1462 jPanelOptionsContainer
1463 .setBorder(javax.swing.BorderFactory
1464 .createEtchedBorder(javax.swing.border.EtchedBorder.RAISED));
1465 */
1466 jPanelOptionsContainer.add(jLabelTagName, null);
1467 jPanelOptionsContainer.add(getJTextFieldTagName(), null);
1468
1469 jPanelOptionsContainer.add(jLabelBuildTargets, null);
1470 jPanelOptionsContainer.add(getJTextFieldBuildTargets(), null);
1471
1472 jPanelOptionsContainer.add(jLabelToolChainFamily, null);
1473 jPanelOptionsContainer.add(getJTextFieldToolChainFamily(), null);
1474
1475 jPanelOptionsContainer.add(jLabelToolCmd, null);
1476 jPanelOptionsContainer.add(getJTextFieldToolCmd(), null);
1477
1478 jPanelOptionsContainer.add(jLabelSupArch, null);
1479 jPanelOptionsContainer.add(getArchitectureSelections(), null);
1480
1481 jPanelOptionsContainer.add(jLabelOptionContents, null);
1482 jPanelOptionsContainer.add(getJTextFieldOptionContents(), null);
1483
1484 jPanelOptionsContainer.add(getJButtonOptionsAdd(), null);
1485 jPanelOptionsContainer.add(getJButtonOptionsDel(), null);
1486 }
1487 return jPanelOptionsContainer;
1488 }
1489
1490 /**
1491 * This method initializes jTextFieldOptionTagName Row 1
1492 *
1493 * @return javax.swing.JTextField
1494 */
1495 private JTextField getJTextFieldTagName() {
1496 if (jTextFieldTagName == null) {
1497 jTextFieldTagName = new JTextField();
1498 jTextFieldTagName.setBounds(new java.awt.Rectangle(fieldColumn, rowOne, fieldWidth, oneRowHeight));
1499 jTextFieldTagName.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1500 jTextFieldTagName.setLocation(new java.awt.Point(fieldColumn, rowOne));
1501 }
1502 return jTextFieldTagName;
1503 }
1504
1505 /**
1506 * This method initializes jTextFieldBuildTargets Row 2
1507 *
1508 * @return javax.swing.JTextField jTextFieldBuildTargets
1509 */
1510 private JTextField getJTextFieldBuildTargets() {
1511 if (jTextFieldBuildTargets == null) {
1512 jTextFieldBuildTargets = new JTextField();
1513 jTextFieldBuildTargets.setBounds(new java.awt.Rectangle(fieldColumn, rowTwo, fieldWidth, oneRowHeight));
1514 jTextFieldBuildTargets.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1515 jTextFieldBuildTargets.setLocation(new java.awt.Point(fieldColumn, rowTwo));
1516 }
1517 return jTextFieldBuildTargets;
1518 }
1519
1520 /**
1521 * This method initializes jTextFieldToolCmd Row 3
1522 *
1523 * This should be a dropdown box of command codes from tools_def.txt
1524 *
1525 * @return javax.swing.JTextField jTextFieldToolCmd
1526 */
1527 private JTextField getJTextFieldToolCmd() {
1528 if (jTextFieldToolCmd == null) {
1529 jTextFieldToolCmd = new JTextField();
1530 jTextFieldToolCmd.setBounds(new java.awt.Rectangle(fieldColumn, rowThree, fieldWidth, oneRowHeight));
1531 jTextFieldToolCmd.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1532 jTextFieldToolCmd.setLocation(new java.awt.Point(fieldColumn, rowThree));
1533 }
1534 return jTextFieldToolCmd;
1535 }
1536
1537 /**
1538 * This method initializes jArchitectureSelections Row 4
1539 *
1540 * @return jArchitectureSelections
1541 */
1542 private JPanel getArchitectureSelections() {
1543 if (jArchitectureSelections == null) {
1544 jArchitectureSelections = new JPanel();
1545 jArchitectureSelections.setLayout(null);
1546 jArchitectureSelections.add(getJCheckBoxIA32(), null);
1547 jArchitectureSelections.add(getJCheckBoxX64(), null);
1548 jArchitectureSelections.add(getJCheckBoxIpf(), null);
1549 jArchitectureSelections.add(getJCheckBoxEBC(), null);
1550 jArchitectureSelections.add(getJCheckBoxARM(), null);
1551 jArchitectureSelections.add(getJCheckBoxPPC(), null);
1552 jArchitectureSelections.setBounds(new java.awt.Rectangle(fieldColumn, rowFour, fieldWidth, oneRowHeight));
1553 jArchitectureSelections.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1554 jArchitectureSelections.setLocation(new java.awt.Point(fieldColumn, rowFour));
1555 }
1556 return jArchitectureSelections;
1557 }
1558
1559 /**
1560 * This method initializes jCheckBoxIA32
1561 *
1562 * @return javax.swing.JCheckBox jCheckBoxIA32
1563 */
1564 private JCheckBox getJCheckBoxIA32() {
1565 if (jCheckBoxIA32 == null) {
1566 jCheckBoxIA32 = new JCheckBox();
1567 jCheckBoxIA32.setBounds(new java.awt.Rectangle(0, 0, 55, 20));
1568 jCheckBoxIA32.setText("IA32");
1569 }
1570 return jCheckBoxIA32;
1571 }
1572
1573 /**
1574 * This method initializes jCheckBoxX64
1575 *
1576 * @return javax.swing.JCheckBox jCheckBoxX64
1577 */
1578 private JCheckBox getJCheckBoxX64() {
1579 if (jCheckBoxX64 == null) {
1580 jCheckBoxX64 = new JCheckBox();
1581 jCheckBoxX64.setText("X64");
1582 jCheckBoxX64.setBounds(new java.awt.Rectangle(55, 0, 53, 20));
1583 }
1584 return jCheckBoxX64;
1585 }
1586
1587 /**
1588 * This method initializes jCheckBoxIpf
1589 *
1590 * @return javax.swing.JCheckBox jCheckBoxIpf
1591 */
1592 private JCheckBox getJCheckBoxIpf() {
1593 if (jCheckBoxIpf == null) {
1594 jCheckBoxIpf = new JCheckBox();
1595 jCheckBoxIpf.setBounds(new java.awt.Rectangle(108, 0, 52, 20));
1596 jCheckBoxIpf.setText("IPF");
1597 }
1598 return jCheckBoxIpf;
1599 }
1600
1601
1602 /**
1603 * This method initializes jCheckBoxEBC
1604 *
1605 * @return javax.swing.JCheckBox jCheckBoxEBC
1606 */
1607 private JCheckBox getJCheckBoxEBC() {
1608 if (jCheckBoxEBC == null) {
1609 jCheckBoxEBC = new JCheckBox();
1610 jCheckBoxEBC.setBounds(new java.awt.Rectangle(160, 0, 53, 20));
1611 jCheckBoxEBC.setText("EBC");
1612 }
1613 return jCheckBoxEBC;
1614 }
1615
1616 /**
1617 * This method initializes jCheckBoxARM
1618 *
1619 * @return javax.swing.JCheckBox jCheckBoxARM
1620 */
1621 private JCheckBox getJCheckBoxARM() {
1622 if (jCheckBoxARM == null) {
1623 jCheckBoxARM = new JCheckBox();
1624 jCheckBoxARM.setBounds(new java.awt.Rectangle(213, 0, 54, 20));
1625 jCheckBoxARM.setText("ARM");
1626 }
1627 return jCheckBoxARM;
1628 }
1629
1630 /**
1631 * This method initializes jCheckBoxPPC
1632 *
1633 * @return javax.swing.JCheckBox jCheckBoxPPC
1634 */
1635 private JCheckBox getJCheckBoxPPC() {
1636 if (jCheckBoxPPC == null) {
1637 jCheckBoxPPC = new JCheckBox();
1638 jCheckBoxPPC.setBounds(new java.awt.Rectangle(267, 0, 53, 20));
1639 jCheckBoxPPC.setText("PPC");
1640 }
1641 return jCheckBoxPPC;
1642 }
1643
1644 /**
1645 * This method initializes jTextFieldToolChainFamily Row 5
1646 *
1647 * This should be a drop down for MSFT, INTEL, GCC or USER_DEFINED
1648 *
1649 * @return javax.swing.JTextField
1650 */
1651 private JTextField getJTextFieldToolChainFamily() {
1652 if (jTextFieldToolChainFamily == null) {
1653 jTextFieldToolChainFamily = new JTextField();
1654 jTextFieldToolChainFamily.setBounds(new java.awt.Rectangle(fieldColumn, rowFive, fieldWidth, oneRowHeight));
1655 jTextFieldToolChainFamily.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1656 jTextFieldToolChainFamily.setLocation(new java.awt.Point(fieldColumn, rowFive));
1657 }
1658 return jTextFieldToolChainFamily;
1659 }
1660
1661 /**
1662 * This method initializes jTextFieldOptionContents Row 6
1663 *
1664 * This is where we should put the checkbox & entry data for the command arguments
1665 *
1666 * @return javax.swing.JTextField
1667 */
1668 private JTextField getJTextFieldOptionContents() {
1669 if (jTextFieldOptionContents == null) {
1670 jTextFieldOptionContents = new JTextField();
1671 jTextFieldOptionContents.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1672 jTextFieldOptionContents.setBounds(fieldColumn, rowSix, fieldWidth, oneRowHeight);
1673 jTextFieldOptionContents.setLocation(new java.awt.Point(fieldColumn, rowSix));
1674 }
1675 return jTextFieldOptionContents;
1676 }
1677
1678 /**
1679 * This method initializes jButtonOptionsAdd
1680 *
1681 * Add entry from the top screen to the table
1682 *
1683 * @return javax.swing.JButton jButtonOptionsAdd
1684 */
1685 private JButton getJButtonOptionsAdd() {
1686 if (jButtonOptionsAdd == null) {
1687 jButtonOptionsAdd = new JButton();
1688 jButtonOptionsAdd.setText("Add");
1689
1690 jButtonOptionsAdd.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight));
1691 jButtonOptionsAdd.setBounds(new java.awt.Rectangle(firstButtonLoc, buttonRow, buttonWidth, oneRowHeight));
1692 jButtonOptionsAdd.setLocation(new java.awt.Point(firstButtonLoc, buttonRow));
1693 jButtonOptionsAdd.addActionListener(new AbstractAction() {
1694 /**
1695 *
1696 */
1697 private static final long serialVersionUID = 1L;
1698
1699 public void actionPerformed(java.awt.event.ActionEvent e) {
1700 boolean[] boolArray = { jCheckBoxIA32.isSelected(), jCheckBoxIpf.isSelected(),
1701 jCheckBoxX64.isSelected(), jCheckBoxEBC.isSelected(),
1702 jCheckBoxARM.isSelected(), jCheckBoxPPC.isSelected() };
1703 String s = boolToList(boolArray);
1704 Object[] o = { jTextFieldBuildTargets.getText(), jTextFieldToolChainFamily.getText(), s,
1705 jTextFieldToolCmd.getText(), jTextFieldTagName.getText(),
1706 jTextFieldOptionContents.getText() };
1707 optionsTableModel.addRow(o);
1708 docConsole.setSaved(false);
1709 ffc.genBuildOptionsOpt(stringToVector(jTextFieldBuildTargets.getText()),
1710 jTextFieldToolChainFamily.getText(), jTextFieldTagName.getText(),
1711 jTextFieldToolCmd.getText(), stringToVector(s),
1712 jTextFieldOptionContents.getText());
1713 }
1714 });
1715 }
1716 return jButtonOptionsAdd;
1717 }
1718
1719 /**
1720 * This method initializes jButtonOptionsDel
1721 *
1722 * Remove a line from the table below
1723 *
1724 * @return javax.swing.JButton jButtonOptionsDel
1725 */
1726 private JButton getJButtonOptionsDel() {
1727 if (jButtonOptionsDel == null) {
1728 jButtonOptionsDel = new JButton();
1729 jButtonOptionsDel.setText("Delete");
1730 jButtonOptionsDel.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight));
1731 jButtonOptionsDel.setBounds(new java.awt.Rectangle(next2LastButtonLoc, buttonRow, buttonWidth, oneRowHeight));
1732 jButtonOptionsDel.setLocation(new java.awt.Point(next2LastButtonLoc, buttonRow));
1733 jButtonOptionsDel.addActionListener(new AbstractAction() {
1734 /**
1735 *
1736 */
1737 private static final long serialVersionUID = 1L;
1738
1739 public void actionPerformed(java.awt.event.ActionEvent e) {
1740 if (selectedRow >= 0) {
1741 optionsTableModel.removeRow(selectedRow);
1742 docConsole.setSaved(false);
1743 ffc.removeBuildOptionsOpt(selectedRow);
1744 }
1745 }
1746 });
1747 }
1748 return jButtonOptionsDel;
1749 }
1750
1751 /**
1752 * This method initializes jScrollPaneOptions
1753 * Contains the Table and is located below the data entry section
1754 * @return javax.swing.JScrollPane jScrollPaneOptoins
1755 */
1756 private JScrollPane getJScrollPaneOptions() {
1757 if (jScrollPaneOptions == null) {
1758 jScrollPaneOptions = new JScrollPane();
1759 jScrollPaneOptions.setPreferredSize(new java.awt.Dimension(dialogWidth, dialogHeight * 2));
1760 jScrollPaneOptions.setBounds(new java.awt.Rectangle(2, (dialogHeight * 2) + 2, dialogWidth * 2, dialogHeight * 2));
1761 jScrollPaneOptions.setLocation(new java.awt.Point(2, dialogHeight + 2));
1762
1763 jScrollPaneOptions.setViewportView(getJTableOptions());
1764 }
1765 return jScrollPaneOptions;
1766 }
1767
1768 /**
1769 * This method initializes jTableOptions
1770 *
1771 * @return javax.swing.JTable jTableOptions
1772 */
1773 private JTable getJTableOptions() {
1774 if (jTableOptions == null) {
1775 jTitle = new JLabel();
1776 jTitle.setText("Current Option Configuration Lines");
1777 jTitle.setBounds(2, 2, labelWidth, oneRowHeight);
1778
1779 optionsTableModel = new DefaultTableModel();
1780 jTableOptions = new JTable(optionsTableModel);
1781 jTableOptions.setRowHeight(20);
1782 optionsTableModel.addColumn("Build Targets");
1783 optionsTableModel.addColumn("Tool Chain Family");
1784 optionsTableModel.addColumn("Supported Architectures");
1785 optionsTableModel.addColumn("Tool Command Code");
1786 optionsTableModel.addColumn("TagName");
1787 optionsTableModel.addColumn("Contents");
1788
1789 javax.swing.table.TableColumn toolFamilyCol = jTableOptions.getColumnModel().getColumn(1);
1790 JComboBox cb = new JComboBox();
1791 cb.addItem("MSFT");
1792 cb.addItem("GCC");
1793 cb.addItem("CYGWIN");
1794 cb.addItem("INTEL");
1795 cb.addItem("USER_DEFINED");
1796 toolFamilyCol.setCellEditor(new DefaultCellEditor(cb));
1797 Vector<String> vArch = new Vector<String>();
1798 vArch.add("IA32");
1799 vArch.add("X64");
1800 vArch.add("IPF");
1801 vArch.add("EBC");
1802 vArch.add("ARM");
1803 vArch.add("PPC");
1804 jTableOptions.getColumnModel().getColumn(2).setCellEditor(new ListEditor(vArch));
1805 jTableOptions.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1806 jTableOptions.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
1807 public void valueChanged(ListSelectionEvent e) {
1808 selectedRow = -1;
1809 if (e.getValueIsAdjusting()) {
1810 return;
1811 }
1812 ListSelectionModel lsm = (ListSelectionModel) e.getSource();
1813 if (lsm.isSelectionEmpty()) {
1814 return;
1815 } else {
1816 selectedRow = lsm.getMinSelectionIndex();
1817 }
1818 }
1819 });
1820
1821 jTableOptions.getModel().addTableModelListener(new TableModelListener() {
1822 public void tableChanged(TableModelEvent arg0) {
1823 // TODO Auto-generated method stub
1824 int row = arg0.getFirstRow();
1825 TableModel m = (TableModel) arg0.getSource();
1826 if (arg0.getType() == TableModelEvent.UPDATE) {
1827 //ToDo Data Validition check.
1828 String targets = m.getValueAt(row, 0) + "";
1829 Vector<Object> targetName = new Vector<Object>();
1830 String[] sArray = targets.split("( )+");
1831 for (int i = 0; i < sArray.length; ++i) {
1832 targetName.add(sArray[i]);
1833 }
1834 String toolChain = m.getValueAt(row, 1) + "";
1835 String archs = m.getValueAt(row, 2) + "";
1836 Vector<Object> supArch = null;
1837 if (archs.length() > 0) {
1838 supArch = new Vector<Object>();
1839 String[] sArray1 = archs.split("( )+");
1840 for (int i = 0; i < sArray1.length; ++i) {
1841 supArch.add(sArray1[i]);
1842 }
1843 }
1844
1845 String toolCmd = m.getValueAt(row, 3) + "";
1846 String tagName = m.getValueAt(row, 4) + "";
1847 String contents = m.getValueAt(row, 5) + "";
1848 docConsole.setSaved(false);
1849 ffc.updateBuildOptionsOpt(row, targetName, toolChain, tagName, toolCmd, supArch, contents);
1850 }
1851 }
1852 });
1853 }
1854 return jTableOptions;
1855 }
1856
1857 private Vector<Object> stringToVector(String s) {
1858 String[] sArray = s.split(" ");
1859 Vector<Object> v = null;
1860 if (s.length() > 0) {
1861 v = new Vector<Object>();
1862 for (int i = 0; i < sArray.length; ++i) {
1863 v.add(sArray[i]);
1864 }
1865 }
1866 return v;
1867 }
1868
1869 private String boolToList(boolean[] bool) {
1870 String s = " ";
1871 if (bool[0]) {
1872 s += "IA32 ";
1873 }
1874 if (bool[1]) {
1875 s += "IPF ";
1876 }
1877 if (bool[2]) {
1878 s += "X64 ";
1879 }
1880 if (bool[3]) {
1881 s += "EBC ";
1882 }
1883 if (bool[4]) {
1884 s += "ARM ";
1885 }
1886 if (bool[5]) {
1887 s += "PPC ";
1888 }
1889 if (s == " ") {
1890 s += "IA32";
1891 }
1892 return s.trim();
1893 }
1894
1895 private void initOptionTable() {
1896 if (ffc.getBuildOptionsOptCount() == 0) {
1897 //ToDo get default options from *.txt file
1898 return;
1899 }
1900 String[][] saa = new String[ffc.getBuildOptionsOptCount()][6];
1901 ffc.getBuildOptionsOpts(saa);
1902 for (int i = 0; i < saa.length; ++i) {
1903 optionsTableModel.addRow(saa[i]);
1904 }
1905 }
1906
1907
1908 /**
1909 * Everything below should pertain to the ANT Task Tab
1910 */
1911
1912 /**
1913 * This method initializes jButton12
1914 *
1915 * @return javax.swing.JButton
1916 */
1917 private JButton getJButtonAntTaskFileBrowse() {
1918 if (jButtonAntTaskFileBrowse == null) {
1919 jButtonAntTaskFileBrowse = new JButton();
1920 jButtonAntTaskFileBrowse.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
1921 jButtonAntTaskFileBrowse.setText("Browse");
1922 jButtonAntTaskFileBrowse.addActionListener(new AbstractAction() {
1923 private static final long serialVersionUID = 1L;
1924
1925 public void actionPerformed(ActionEvent arg0) {
1926 //
1927 // Select files from current workspace
1928 //
1929 String dirPrefix = System.getenv("WORKSPACE");
1930 JFileChooser chooser = new JFileChooser(dirPrefix);
1931 File theFile = null;
1932 String headerDest = null;
1933
1934 chooser.setMultiSelectionEnabled(false);
1935 chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
1936 int retval = chooser.showOpenDialog(frame);
1937 if (retval == JFileChooser.APPROVE_OPTION) {
1938
1939 theFile = chooser.getSelectedFile();
1940 String file = theFile.getPath();
1941 if (!file.startsWith(dirPrefix)) {
1942 JOptionPane.showMessageDialog(frame, "You can only select files in current package!");
1943 return;
1944 }
1945 } else {
1946 return;
1947 }
1948
1949 headerDest = theFile.getPath();
1950 jTextFieldAntTaskFile.setText(headerDest.substring(dirPrefix.length()).replace('\\', '/'));
1951
1952 }
1953
1954 });
1955 }
1956 return jButtonAntTaskFileBrowse;
1957 }
1958
1959 /**
1960 * This method initializes jPanelUserDefCenterN
1961 *
1962 * @return javax.swing.JPanel
1963 */
1964 private JPanel getJPanelUserDefCenterN() {
1965 if (jPanelUserDefCenterN == null) {
1966 jPanelUserDefCenterN = new JPanel();
1967 jPanelUserDefCenterN.add(jLabelAntCmdOpts, null);
1968 jPanelUserDefCenterN.add(getJTextFieldAntCmdOpts(), null);
1969 jPanelUserDefCenterN.add(getJButtonAntTaskAdd(), null);
1970 jPanelUserDefCenterN.add(getJButtonAntTaskDel(), null);
1971 }
1972 return jPanelUserDefCenterN;
1973 }
1974
1975 /**
1976 * This method initializes jPanelUserDefCenterC
1977 *
1978 * @return javax.swing.JPanel
1979 */
1980 private JPanel getJPanelUserDefCenterC() {
1981 if (jPanelUserDefCenterC == null) {
1982 jPanelUserDefCenterC = new JPanel();
1983 jPanelUserDefCenterC.add(getJScrollPaneAntTasks(), null);
1984 }
1985 return jPanelUserDefCenterC;
1986 }
1987
1988 /**
1989 * This method initializes jPanel8
1990 *
1991 * @return javax.swing.JPanel
1992 */
1993 private JPanel getJPanelUserDef() {
1994 if (jPanelUserDef == null) {
1995 jPanelUserDef = new JPanel();
1996 jPanelUserDef.setLayout(new BorderLayout());
1997 jPanelUserDef.add(getJPanelUserDefNorth(), java.awt.BorderLayout.NORTH);
1998 jPanelUserDef.add(getJPanelUserDefCenter(), java.awt.BorderLayout.CENTER);
1999
2000 }
2001 return jPanelUserDef;
2002 }
2003
2004 /**
2005 * This method initializes jPanel9
2006 *
2007 * @return javax.swing.JPanel
2008 */
2009 private JPanel getJPanelUserDefNorth() {
2010 if (jPanelUserDefNorth == null) {
2011 jLabelAntTaskFile = new JLabel();
2012 jLabelAntTaskFile.setText("ANT Task File");
2013 jLabelAntTaskFile.setPreferredSize(new java.awt.Dimension(80, 20));
2014 FlowLayout flowLayout8 = new FlowLayout();
2015 flowLayout8.setAlignment(java.awt.FlowLayout.CENTER);
2016 jLabelAntTaskId = new JLabel();
2017 jLabelAntTaskId.setText("ID");
2018 jPanelUserDefNorth = new JPanel();
2019 jPanelUserDefNorth.setLayout(flowLayout8);
2020 jPanelUserDefNorth.add(jLabelAntTaskFile, null);
2021 jPanelUserDefNorth.add(getJTextFieldAntTaskFile(), null);
2022 jPanelUserDefNorth.add(getJButtonAntTaskFileBrowse(), null);
2023 jPanelUserDefNorth.add(jLabelAntTaskId, null);
2024 jPanelUserDefNorth.add(getJTextFieldAntTaskId(), null);
2025 }
2026 return jPanelUserDefNorth;
2027 }
2028
2029 /**
2030 * This method initializes jPanel11
2031 *
2032 * @return javax.swing.JPanel
2033 */
2034 private JPanel getJPanelUserDefCenter() {
2035 if (jPanelUserDefCenter == null) {
2036 jLabelAntCmdOpts = new JLabel();
2037 jLabelAntCmdOpts.setText("ANT Command Options");
2038 jLabelAntCmdOpts.setPreferredSize(new java.awt.Dimension(131, 20));
2039 jPanelUserDefCenter = new JPanel();
2040 jPanelUserDefCenter.setLayout(new BorderLayout());
2041
2042 jPanelUserDefCenter.add(getJPanelUserDefCenterN(), java.awt.BorderLayout.NORTH);
2043 jPanelUserDefCenter.add(getJPanelUserDefCenterC(), java.awt.BorderLayout.CENTER);
2044 }
2045 return jPanelUserDefCenter;
2046 }
2047
2048 /**
2049 * This method initializes jTextField2
2050 *
2051 * @return javax.swing.JTextField
2052 */
2053 private JTextField getJTextFieldAntTaskFile() {
2054 if (jTextFieldAntTaskFile == null) {
2055 jTextFieldAntTaskFile = new JTextField();
2056 jTextFieldAntTaskFile.setPreferredSize(new java.awt.Dimension(200, 20));
2057 }
2058 return jTextFieldAntTaskFile;
2059 }
2060
2061 /**
2062 * This method initializes jTextField3
2063 *
2064 * @return javax.swing.JTextField
2065 */
2066 private JTextField getJTextFieldAntTaskId() {
2067 if (jTextFieldAntTaskId == null) {
2068 jTextFieldAntTaskId = new JTextField();
2069 jTextFieldAntTaskId.setPreferredSize(new java.awt.Dimension(100, 20));
2070 }
2071 return jTextFieldAntTaskId;
2072 }
2073
2074 /**
2075 * This method initializes jButton4
2076 *
2077 * @return javax.swing.JButton
2078 */
2079 private JButton getJButtonAntTaskAdd() {
2080 if (jButtonAntTaskAdd == null) {
2081 jButtonAntTaskAdd = new JButton();
2082 jButtonAntTaskAdd.setPreferredSize(new java.awt.Dimension(90, 20));
2083 jButtonAntTaskAdd.setText("Add");
2084 jButtonAntTaskAdd.addActionListener(new ActionListener() {
2085 public void actionPerformed(ActionEvent e) {
2086 if (!DataValidation.isInt(jTextFieldAntTaskId.getText())
2087 || jTextFieldAntTaskId.getText().length() != 8) {
2088 JOptionPane.showMessageDialog(frame, "ID must be an 8-digit integer.");
2089 return;
2090 }
2091 Object[] o = { jTextFieldAntTaskId.getText(), null, null };
2092 o[1] = jTextFieldAntTaskFile.getText();
2093 o[2] = jTextFieldAntCmdOpts.getText();
2094 ffc.genBuildOptionsUserDefAntTask(o[0] + "", o[1] + "", o[2] + "");
2095 antTaskTableModel.addRow(o);
2096 docConsole.setSaved(false);
2097 }
2098 });
2099 }
2100 return jButtonAntTaskAdd;
2101 }
2102
2103 /**
2104 * This method initializes jButton5
2105 *
2106 * @return javax.swing.JButton
2107 */
2108 private JButton getJButtonAntTaskDel() {
2109 if (jButtonAntTaskDel == null) {
2110 jButtonAntTaskDel = new JButton();
2111 jButtonAntTaskDel.setPreferredSize(new java.awt.Dimension(90, 20));
2112 jButtonAntTaskDel.setText("Delete");
2113 jButtonAntTaskDel.addActionListener(new ActionListener() {
2114 public void actionPerformed(ActionEvent e) {
2115 if (selectedRow >= 0) {
2116 docConsole.setSaved(false);
2117 antTaskTableModel.removeRow(selectedRow);
2118 ffc.removeBuildOptionsUserDefAntTask(selectedRow);
2119 }
2120 }
2121 });
2122 }
2123 return jButtonAntTaskDel;
2124 }
2125
2126 /**
2127 * This method initializes jTextField4
2128 *
2129 * @return javax.swing.JTextField
2130 */
2131 private JTextField getJTextFieldAntCmdOpts() {
2132 if (jTextFieldAntCmdOpts == null) {
2133 jTextFieldAntCmdOpts = new JTextField();
2134 jTextFieldAntCmdOpts.setPreferredSize(new java.awt.Dimension(270, 20));
2135 jTextFieldAntCmdOpts.setEnabled(true);
2136 }
2137 return jTextFieldAntCmdOpts;
2138 }
2139
2140 /**
2141 * This method initializes jScrollPane2
2142 *
2143 * @return javax.swing.JScrollPane
2144 */
2145 private JScrollPane getJScrollPaneAntTasks() {
2146 if (jScrollPaneAntTasks == null) {
2147 jScrollPaneAntTasks = new JScrollPane();
2148 jScrollPaneAntTasks.setPreferredSize(new java.awt.Dimension(600, 400));
2149 jScrollPaneAntTasks.setViewportView(getJTableAntTasks());
2150 }
2151 return jScrollPaneAntTasks;
2152 }
2153
2154 /**
2155 * This method initializes jTable2
2156 *
2157 * @return javax.swing.JTable
2158 */
2159 private JTable getJTableAntTasks() {
2160 if (jTableAntTasks == null) {
2161 antTaskTableModel = new DefaultTableModel();
2162 jTableAntTasks = new JTable(antTaskTableModel);
2163 jTableAntTasks.setRowHeight(20);
2164 antTaskTableModel.addColumn("ID");
2165 antTaskTableModel.addColumn("Filename");
2166 antTaskTableModel.addColumn("ANT Command Options");
2167
2168 jTableAntTasks.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
2169 jTableAntTasks.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
2170 public void valueChanged(ListSelectionEvent e) {
2171 selectedRow = -1;
2172 if (e.getValueIsAdjusting()) {
2173 return;
2174 }
2175 ListSelectionModel lsm = (ListSelectionModel) e.getSource();
2176 if (lsm.isSelectionEmpty()) {
2177 return;
2178 } else {
2179 selectedRow = lsm.getMinSelectionIndex();
2180 }
2181 }
2182 });
2183
2184 jTableAntTasks.getModel().addTableModelListener(new TableModelListener() {
2185 public void tableChanged(TableModelEvent arg0) {
2186 // TODO Auto-generated method stub
2187 int row = arg0.getFirstRow();
2188 TableModel m = (TableModel) arg0.getSource();
2189 if (arg0.getType() == TableModelEvent.UPDATE) {
2190 //ToDo Data Validition check.
2191 String id = m.getValueAt(row, 0) + "";
2192 String file = m.getValueAt(row, 1) + "";
2193 String execOrder = m.getValueAt(row, 2) + "";
2194 if (id.length() == 0) {
2195 return;
2196 }
2197 if (file.length() == 0 && execOrder.length() == 0) {
2198 return;
2199 }
2200 if (file.length() == 0) {
2201 file = null;
2202 }
2203 if (execOrder.length() == 0) {
2204 execOrder = null;
2205 }
2206 ffc.updateBuildOptionsUserDefAntTask(row, id, file, execOrder);
2207
2208 }
2209 }
2210 });
2211 }
2212 return jTableAntTasks;
2213 }
2214
2215 private void initAntTaskTable() {
2216 if (ffc.getBuildOptionsUserDefAntTaskCount() == 0) {
2217 return;
2218 }
2219 String[][] saa = new String[ffc.getBuildOptionsUserDefAntTaskCount()][3];
2220 ffc.getBuildOptionsUserDefAntTasks(saa);
2221 for (int i = 0; i < saa.length; ++i) {
2222 antTaskTableModel.addRow(saa[i]);
2223 }
2224 }
2225
2226 } // @jve:decl-index=0:visual-constraint="10,10"