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