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                 }
1154             });
1155         }
1156         return jButtonFfsSectionsNew;
1157     }
1158
1159     /**
1160      * This method initializes jButton7
1161      *
1162      * @return javax.swing.JButton
1163      */
1164     private JButton getJButtonFfsSectionsRemove() {
1165         if (jButtonFfsSectionsRemove == null) {
1166             jButtonFfsSectionsRemove = new JButton();
1167             jButtonFfsSectionsRemove.setPreferredSize(new java.awt.Dimension(80, 20));
1168             jButtonFfsSectionsRemove.setText("Remove");
1169             jButtonFfsSectionsRemove.addActionListener(new java.awt.event.ActionListener() {
1170                 public void actionPerformed(java.awt.event.ActionEvent e) {
1171                     if (jTableFfs.getSelectedRow() < 0 || jTableFfsSections.getSelectedRow() < 0) {
1172                         return;
1173                     }
1174                     docConsole.setSaved(false);
1175                     sectionsTableModel.removeRow(jTableFfsSections.getSelectedRow());
1176                     ffc.removeBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(),
1177                                                               jTableFfsSections.getSelectedRow());
1178                     subsectionsTableModel.setRowCount(0);
1179                 }
1180             });
1181         }
1182         return jButtonFfsSectionsRemove;
1183     }
1184
1185     private JScrollPane getJScrollPaneFfsSections() {
1186         if (jScrollPaneFfsSections == null) {
1187             jScrollPaneFfsSections = new JScrollPane();
1188 //            jScrollPaneFfsSections.setPreferredSize(new java.awt.Dimension(500, 80));
1189             jScrollPaneFfsSections.setViewportView(getJTableFfsSections());
1190         }
1191         return jScrollPaneFfsSections;
1192     }
1193
1194     /**
1195      * This method initializes jTable6
1196      *
1197      * @return javax.swing.JTable
1198      */
1199     private JTable getJTableFfsSections() {
1200         if (jTableFfsSections == null) {
1201             sectionsTableModel = new DefaultTableModel();
1202             sectionsTableModel.addColumn("EncapsulationType");
1203             jTableFfsSections = new JTable(sectionsTableModel);
1204             jTableFfsSections.setRowHeight(20);
1205             jTableFfsSections.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1206             jTableFfsSections.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
1207                 public void valueChanged(ListSelectionEvent e) {
1208                     if (e.getValueIsAdjusting()) {
1209                         return;
1210                     }
1211                     ListSelectionModel lsm = (ListSelectionModel) e.getSource();
1212                     if (lsm.isSelectionEmpty()) {
1213                         return;
1214                     } else {
1215                         int sectionsRow = lsm.getMinSelectionIndex();
1216                         if (jTableFfs.getSelectedRow() < 0) {
1217                             return;
1218                         }
1219                         subsectionsTableModel.setRowCount(0);
1220                         ArrayList<String> al = new ArrayList<String>();
1221                         ffc.getBuildOptionsFfsSectionsSectionsSection(jTableFfs.getSelectedRow(), sectionsRow, al);
1222                         for (int i = 0; i < al.size(); ++i) {
1223                             String[] subsectionRow = { al.get(i) };
1224                             subsectionsTableModel.addRow(subsectionRow);
1225                         }
1226                     }
1227                 }
1228             });
1229
1230             jTableFfsSections.getModel().addTableModelListener(new TableModelListener() {
1231                 public void tableChanged(TableModelEvent arg0) {
1232                     // TODO Auto-generated method stub
1233                     int row = arg0.getFirstRow();
1234                     TableModel m = (TableModel) arg0.getSource();
1235                     if (arg0.getType() == TableModelEvent.UPDATE) {
1236                         //ToDo Data Validition check.
1237                         String encapType = m.getValueAt(row, 0) + "";
1238                         docConsole.setSaved(false);
1239                         ffc.updateBuildOptionsFfsSectionsSections(jTableFfs.getSelectedRow(), row, encapType);
1240                     }
1241                 }
1242             });
1243         }
1244         return jTableFfsSections;
1245     }
1246
1247     /**
1248      * This method initializes jSplitPaneFfsC
1249      *
1250      * @return javax.swing.JSplitPane
1251      */
1252     private JSplitPane getJSplitPaneFfsC() {
1253         if (jSplitPaneFfsC == null) {
1254             jSplitPaneFfsC = new JSplitPane();
1255             jSplitPaneFfsC.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1256             jSplitPaneFfsC.setDividerLocation(130);
1257             jSplitPaneFfsC.setTopComponent(getJPanelFfsCTop());
1258             jSplitPaneFfsC.setBottomComponent(getJSplitPaneFfsCBottom());
1259             jSplitPaneFfsC.setDividerSize(5);
1260         }
1261         return jSplitPaneFfsC;
1262     }
1263
1264     /**
1265      * This method initializes jPanelFfsCTop
1266      *
1267      * @return javax.swing.JPanel
1268      */
1269     private JPanel getJPanelFfsCTop() {
1270         if (jPanelFfsCTop == null) {
1271             jPanelFfsCTop = new JPanel();
1272             jPanelFfsCTop.setLayout(new BorderLayout());
1273             jPanelFfsCTop.add(getJPanelSectionN(), java.awt.BorderLayout.NORTH);
1274             jPanelFfsCTop.add(getJScrollPaneFfsSection(), java.awt.BorderLayout.CENTER);
1275         }
1276         return jPanelFfsCTop;
1277     }
1278
1279     /**
1280      * This method initializes jSplitPaneFfsCBottom
1281      *
1282      * @return javax.swing.JSplitPane
1283      */
1284     private JSplitPane getJSplitPaneFfsCBottom() {
1285         if (jSplitPaneFfsCBottom == null) {
1286             jSplitPaneFfsCBottom = new JSplitPane();
1287             jSplitPaneFfsCBottom.setDividerSize(5);
1288             jSplitPaneFfsCBottom.setDividerLocation(130);
1289             jSplitPaneFfsCBottom.setTopComponent(getJPanelFfsCBottomTop());
1290             jSplitPaneFfsCBottom.setBottomComponent(getJPanelFfsCBottomBottom());
1291             jSplitPaneFfsCBottom.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1292         }
1293         return jSplitPaneFfsCBottom;
1294     }
1295
1296     /**
1297      * This method initializes jPanelFfsCBottomTop
1298      *
1299      * @return javax.swing.JPanel
1300      */
1301     private JPanel getJPanelFfsCBottomTop() {
1302         if (jPanelFfsCBottomTop == null) {
1303             jPanelFfsCBottomTop = new JPanel();
1304             jPanelFfsCBottomTop.setLayout(new BorderLayout());
1305             jPanelFfsCBottomTop.add(getJPanelSectionsN(), java.awt.BorderLayout.NORTH);
1306             jPanelFfsCBottomTop.add(getJScrollPaneFfsSections(), java.awt.BorderLayout.CENTER);
1307         }
1308         return jPanelFfsCBottomTop;
1309     }
1310
1311     /**
1312      * This method initializes jPanelFfsCBottomBottom
1313      *
1314      * @return javax.swing.JPanel
1315      */
1316     private JPanel getJPanelFfsCBottomBottom() {
1317         if (jPanelFfsCBottomBottom == null) {
1318             jPanelFfsCBottomBottom = new JPanel();
1319             jPanelFfsCBottomBottom.setLayout(new BorderLayout());
1320             jPanelFfsCBottomBottom.add(getJPanelSubSectionN(), java.awt.BorderLayout.NORTH);
1321             jPanelFfsCBottomBottom.add(getJScrollPaneFfsSubSection(), java.awt.BorderLayout.CENTER);
1322         }
1323         return jPanelFfsCBottomBottom;
1324     }
1325
1326     /**
1327      * This method initializes jPanelSectionN
1328      *
1329      * @return javax.swing.JPanel
1330      */
1331     private JPanel getJPanelSectionN() {
1332         if (jPanelSectionN == null) {
1333             jPanelSectionN = new JPanel();
1334             jLabelFfsSection = new JLabel();
1335             jLabelFfsSection.setText("Section");
1336             jPanelSectionN.add(jLabelFfsSection, null);
1337             jPanelSectionN.add(getJButtonFfsSectionNew(), null);
1338             jPanelSectionN.add(getJButtonFfsSectionRemove(), null);
1339         }
1340         return jPanelSectionN;
1341     }
1342
1343     /**
1344      * This method initializes jPanelSectionsN
1345      *
1346      * @return javax.swing.JPanel
1347      */
1348     private JPanel getJPanelSectionsN() {
1349         if (jPanelSectionsN == null) {
1350             jPanelSectionsN = new JPanel();
1351             jLabelFfsSections = new JLabel();
1352             jLabelFfsSections.setText("Sections");
1353             jPanelSectionsN.add(jLabelFfsSections, null);
1354             jPanelSectionsN.add(getJButtonFfsSectionsNew(), null);
1355             jPanelSectionsN.add(getJButtonFfsSectionsRemove(), null);
1356         }
1357         return jPanelSectionsN;
1358     }
1359
1360     /**
1361      * This method initializes jPanelSubSectionN
1362      *
1363      * @return javax.swing.JPanel
1364      */
1365     private JPanel getJPanelSubSectionN() {
1366         if (jPanelSubSectionN == null) {
1367             jPanelSubSectionN = new JPanel();
1368             jLabelFfsSubSections = new JLabel();
1369             jLabelFfsSubSections.setText("Sub-Sections");
1370             jPanelSubSectionN.add(jLabelFfsSubSections, null);
1371             jPanelSubSectionN.add(getJButtonFfsSubSectionNew(), null);
1372             jPanelSubSectionN.add(getJButtonFfsSubSectionRemove(), null);
1373         }
1374         return jPanelSubSectionN;
1375     }
1376
1377     /**
1378      * The following section contains all Build Options content
1379      */
1380
1381     /**
1382      * This method initializes jPanelOptionsTab
1383      *
1384      * This is the main Options screen
1385      *
1386      * @return javax.swing.JPanel       jPanelOptionsTab
1387      */
1388     private JPanel getJPanelOptionsTab() {
1389         if (jPanelOptionsTab == null) {
1390             // This container holds the Options Tab content
1391
1392             //            FlowLayout flowLayout9 = new FlowLayout();
1393             //            flowLayout9.setAlignment(java.awt.FlowLayout.LEFT);
1394
1395             GridLayout gridLayout = new GridLayout();
1396             gridLayout.setRows(2);
1397             jPanelOptionsTab = new JPanel();
1398             jPanelOptionsTab.setLayout(gridLayout);
1399             jPanelOptionsTab.setBounds(new java.awt.Rectangle(0, 0, dialogWidth * 2, dialogHeight * 3));
1400             jPanelOptionsTab.setPreferredSize(new java.awt.Dimension(dialogWidth + 10, (dialogHeight * 3) + 10));
1401             jPanelOptionsTab.setAutoscrolls(true);
1402             jPanelOptionsTab.setLocation(0, 0);
1403             jPanelOptionsTab.add(getJPanelOptionsContainer(), null);
1404 //            jPanelOptionsTab.add(getJScrollPaneOptions(), null);
1405             jPanelOptionsTab.add(getJPanelTableOptionsContainer(), null);
1406         }
1407         return jPanelOptionsTab;
1408     }
1409
1410     /**
1411      * This method initializes jPanelOptionsContainer
1412      *
1413      * @return javax.swing.JPanel
1414      */
1415     private JPanel getJPanelOptionsContainer() {
1416         if (jPanelOptionsContainer == null) {
1417             jLabelTagName = new JLabel();
1418             jLabelTagName.setBounds(new java.awt.Rectangle(labelColumn, rowOne, labelWidth, oneRowHeight));
1419             jLabelTagName.setLocation(new java.awt.Point(labelColumn, rowOne));
1420             jLabelTagName.setText("Tag Name");
1421             jLabelBuildTargets = new JLabel();
1422             jLabelBuildTargets.setBounds(new java.awt.Rectangle(labelColumn, rowTwo, labelWidth, oneRowHeight));
1423             jLabelBuildTargets.setLocation(new java.awt.Point(labelColumn, rowTwo));
1424             jLabelBuildTargets.setText("Build Targets");
1425             jLabelToolCmd = new JLabel();
1426             jLabelToolCmd.setBounds(new java.awt.Rectangle(labelColumn, rowThree, labelWidth, oneRowHeight));
1427             jLabelToolCmd.setLocation(new java.awt.Point(labelColumn, rowThree));
1428             jLabelToolCmd.setText("Tool Command");
1429             jLabelSupArch = new JLabel();
1430             jLabelSupArch.setBounds(new java.awt.Rectangle(labelColumn, rowFour, labelWidth, oneRowHeight));
1431             jLabelSupArch.setLocation(new java.awt.Point(labelColumn, rowFour));
1432             jLabelSupArch.setText("Supported Architectures");
1433             jLabelToolChainFamily = new JLabel();
1434             jLabelToolChainFamily.setBounds(new java.awt.Rectangle(labelColumn, rowFive, labelWidth, oneRowHeight));
1435             jLabelToolChainFamily.setLocation(new java.awt.Point(labelColumn, rowFive));
1436             jLabelToolChainFamily.setText("Tool Chain Family");
1437
1438             jLabelOptionContents = new JLabel();
1439             jLabelOptionContents.setBounds(new java.awt.Rectangle(labelColumn, rowSix, labelWidth, oneRowHeight));
1440             jLabelOptionContents.setLocation(new java.awt.Point(labelColumn, rowSix));
1441             jLabelOptionContents.setText("Argument Strings");
1442
1443             jPanelOptionsContainer = new JPanel();
1444
1445             jPanelOptionsContainer.setLayout(null);
1446
1447             jPanelOptionsContainer.setPreferredSize(new java.awt.Dimension(dialogWidth, dialogHeight));
1448             /*
1449             jPanelOptionsContainer
1450                                   .setBorder(javax.swing.BorderFactory
1451                                                                       .createEtchedBorder(javax.swing.border.EtchedBorder.RAISED));
1452 */
1453             jPanelOptionsContainer.add(jLabelTagName, null);
1454             jPanelOptionsContainer.add(getJTextFieldTagName(), null);
1455
1456             jPanelOptionsContainer.add(jLabelBuildTargets, null);
1457             jPanelOptionsContainer.add(getJTextFieldBuildTargets(), null);
1458
1459             jPanelOptionsContainer.add(jLabelToolChainFamily, null);
1460             jPanelOptionsContainer.add(getJTextFieldToolChainFamily(), null);
1461
1462             jPanelOptionsContainer.add(jLabelToolCmd, null);
1463             jPanelOptionsContainer.add(getJTextFieldToolCmd(), null);
1464
1465             jPanelOptionsContainer.add(jLabelSupArch, null);
1466             jPanelOptionsContainer.add(getArchitectureSelections(), null);
1467
1468             jPanelOptionsContainer.add(jLabelOptionContents, null);
1469             jPanelOptionsContainer.add(getJTextFieldOptionContents(), null);
1470
1471             jPanelOptionsContainer.add(getJButtonOptionsAdd(), null);
1472             jPanelOptionsContainer.add(getJButtonOptionsDel(), null);
1473         }
1474         return jPanelOptionsContainer;
1475     }
1476
1477     /**
1478      * This method initializes jTextFieldOptionTagName  Row 1
1479      *
1480      * @return javax.swing.JTextField
1481      */
1482     private JTextField getJTextFieldTagName() {
1483         if (jTextFieldTagName == null) {
1484             jTextFieldTagName = new JTextField();
1485             jTextFieldTagName.setBounds(new java.awt.Rectangle(fieldColumn, rowOne, fieldWidth, oneRowHeight));
1486             jTextFieldTagName.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1487             jTextFieldTagName.setLocation(new java.awt.Point(fieldColumn, rowOne));
1488         }
1489         return jTextFieldTagName;
1490     }
1491
1492     /**
1493      * This method initializes jTextFieldBuildTargets  Row 2
1494      *
1495      * @return javax.swing.JTextField   jTextFieldBuildTargets
1496      */
1497     private JTextField getJTextFieldBuildTargets() {
1498         if (jTextFieldBuildTargets == null) {
1499             jTextFieldBuildTargets = new JTextField();
1500             jTextFieldBuildTargets.setBounds(new java.awt.Rectangle(fieldColumn, rowTwo, fieldWidth, oneRowHeight));
1501             jTextFieldBuildTargets.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1502             jTextFieldBuildTargets.setLocation(new java.awt.Point(fieldColumn, rowTwo));
1503         }
1504         return jTextFieldBuildTargets;
1505     }
1506
1507     /**
1508      * This method initializes jTextFieldToolCmd Row 3
1509      *
1510      *  This should be a dropdown box of command codes from tools_def.txt
1511      *
1512      * @return javax.swing.JTextField   jTextFieldToolCmd
1513      */
1514     private JTextField getJTextFieldToolCmd() {
1515         if (jTextFieldToolCmd == null) {
1516             jTextFieldToolCmd = new JTextField();
1517             jTextFieldToolCmd.setBounds(new java.awt.Rectangle(fieldColumn, rowThree, fieldWidth, oneRowHeight));
1518             jTextFieldToolCmd.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1519             jTextFieldToolCmd.setLocation(new java.awt.Point(fieldColumn, rowThree));
1520         }
1521         return jTextFieldToolCmd;
1522     }
1523
1524     /**
1525      * This method initializes jArchitectureSelections Row 4
1526      *
1527      * @return jArchitectureSelections
1528      */
1529     private JPanel getArchitectureSelections() {
1530         if (jArchitectureSelections == null) {
1531             jArchitectureSelections = new JPanel();
1532             jArchitectureSelections.setLayout(null);
1533             jArchitectureSelections.add(getJCheckBoxIA32(), null);
1534             jArchitectureSelections.add(getJCheckBoxX64(), null);
1535             jArchitectureSelections.add(getJCheckBoxIpf(), null);
1536             jArchitectureSelections.add(getJCheckBoxEBC(), null);
1537             jArchitectureSelections.add(getJCheckBoxARM(), null);
1538             jArchitectureSelections.add(getJCheckBoxPPC(), null);
1539             jArchitectureSelections.setBounds(new java.awt.Rectangle(fieldColumn, rowFour, fieldWidth, oneRowHeight));
1540             jArchitectureSelections.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1541             jArchitectureSelections.setLocation(new java.awt.Point(fieldColumn, rowFour));
1542         }
1543         return jArchitectureSelections;
1544     }
1545
1546     /**
1547      * This method initializes jCheckBoxIA32
1548      *
1549      * @return javax.swing.JCheckBox    jCheckBoxIA32
1550      */
1551     private JCheckBox getJCheckBoxIA32() {
1552         if (jCheckBoxIA32 == null) {
1553             jCheckBoxIA32 = new JCheckBox();
1554             jCheckBoxIA32.setBounds(new java.awt.Rectangle(0, 0, 55, 20));
1555             jCheckBoxIA32.setText("IA32");
1556         }
1557         return jCheckBoxIA32;
1558     }
1559
1560     /**
1561      * This method initializes jCheckBoxX64
1562      *
1563      * @return javax.swing.JCheckBox    jCheckBoxX64
1564      */
1565     private JCheckBox getJCheckBoxX64() {
1566         if (jCheckBoxX64 == null) {
1567             jCheckBoxX64 = new JCheckBox();
1568             jCheckBoxX64.setText("X64");
1569             jCheckBoxX64.setBounds(new java.awt.Rectangle(55, 0, 53, 20));
1570         }
1571         return jCheckBoxX64;
1572     }
1573
1574     /**
1575      * This method initializes jCheckBoxIpf
1576      *
1577      * @return javax.swing.JCheckBox    jCheckBoxIpf
1578      */
1579     private JCheckBox getJCheckBoxIpf() {
1580         if (jCheckBoxIpf == null) {
1581             jCheckBoxIpf = new JCheckBox();
1582             jCheckBoxIpf.setBounds(new java.awt.Rectangle(108, 0, 52, 20));
1583             jCheckBoxIpf.setText("IPF");
1584         }
1585         return jCheckBoxIpf;
1586     }
1587
1588
1589     /**
1590      * This method initializes jCheckBoxEBC
1591      *
1592      * @return javax.swing.JCheckBox    jCheckBoxEBC
1593      */
1594     private JCheckBox getJCheckBoxEBC() {
1595         if (jCheckBoxEBC == null) {
1596             jCheckBoxEBC = new JCheckBox();
1597             jCheckBoxEBC.setBounds(new java.awt.Rectangle(160, 0, 53, 20));
1598             jCheckBoxEBC.setText("EBC");
1599         }
1600         return jCheckBoxEBC;
1601     }
1602
1603     /**
1604      * This method initializes jCheckBoxARM
1605      *
1606      * @return javax.swing.JCheckBox    jCheckBoxARM
1607      */
1608     private JCheckBox getJCheckBoxARM() {
1609         if (jCheckBoxARM == null) {
1610             jCheckBoxARM = new JCheckBox();
1611             jCheckBoxARM.setBounds(new java.awt.Rectangle(213, 0, 54, 20));
1612             jCheckBoxARM.setText("ARM");
1613         }
1614         return jCheckBoxARM;
1615     }
1616
1617     /**
1618      * This method initializes jCheckBoxPPC
1619      *
1620      * @return javax.swing.JCheckBox    jCheckBoxPPC
1621      */
1622     private JCheckBox getJCheckBoxPPC() {
1623         if (jCheckBoxPPC == null) {
1624             jCheckBoxPPC = new JCheckBox();
1625             jCheckBoxPPC.setBounds(new java.awt.Rectangle(267, 0, 53, 20));
1626             jCheckBoxPPC.setText("PPC");
1627         }
1628         return jCheckBoxPPC;
1629     }
1630
1631     /**
1632      * This method initializes jTextFieldToolChainFamily  Row 5
1633      *
1634      * This should be a drop down for MSFT, INTEL, GCC or USER_DEFINED
1635      *
1636      * @return javax.swing.JTextField
1637      */
1638     private JTextField getJTextFieldToolChainFamily() {
1639         if (jTextFieldToolChainFamily == null) {
1640             jTextFieldToolChainFamily = new JTextField();
1641             jTextFieldToolChainFamily.setBounds(new java.awt.Rectangle(fieldColumn, rowFive, fieldWidth, oneRowHeight));
1642             jTextFieldToolChainFamily.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1643             jTextFieldToolChainFamily.setLocation(new java.awt.Point(fieldColumn, rowFive));
1644         }
1645         return jTextFieldToolChainFamily;
1646     }
1647
1648     /**
1649      * This method initializes jTextFieldOptionContents Row 6
1650      *
1651      *  This is where we should put the checkbox & entry data for the command arguments
1652      *
1653      * @return javax.swing.JTextField
1654      */
1655     private JTextField getJTextFieldOptionContents() {
1656         if (jTextFieldOptionContents == null) {
1657             jTextFieldOptionContents = new JTextField();
1658             jTextFieldOptionContents.setPreferredSize(new java.awt.Dimension(fieldWidth, oneRowHeight));
1659             jTextFieldOptionContents.setBounds(fieldColumn, rowSix, fieldWidth, oneRowHeight);
1660             jTextFieldOptionContents.setLocation(new java.awt.Point(fieldColumn, rowSix));
1661         }
1662         return jTextFieldOptionContents;
1663     }
1664
1665     /**
1666      * This method initializes jButtonOptionsAdd
1667      *
1668      * Add entry from the top screen to the table
1669      *
1670      * @return javax.swing.JButton  jButtonOptionsAdd
1671      */
1672     private JButton getJButtonOptionsAdd() {
1673         if (jButtonOptionsAdd == null) {
1674             jButtonOptionsAdd = new JButton();
1675             jButtonOptionsAdd.setText("Add");
1676
1677             jButtonOptionsAdd.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight));
1678             jButtonOptionsAdd.setBounds(new java.awt.Rectangle(firstButtonLoc, buttonRow, buttonWidth, oneRowHeight));
1679             jButtonOptionsAdd.setLocation(new java.awt.Point(firstButtonLoc, buttonRow));
1680             jButtonOptionsAdd.addActionListener(new AbstractAction() {
1681                 /**
1682                  *
1683                  */
1684                 private static final long serialVersionUID = 1L;
1685
1686                 public void actionPerformed(java.awt.event.ActionEvent e) {
1687                     boolean[] boolArray = { jCheckBoxIA32.isSelected(), jCheckBoxIpf.isSelected(),
1688                                            jCheckBoxX64.isSelected(), jCheckBoxEBC.isSelected(),
1689                                            jCheckBoxARM.isSelected(), jCheckBoxPPC.isSelected() };
1690                     String s = boolToList(boolArray);
1691                     Object[] o = { jTextFieldBuildTargets.getText(), jTextFieldToolChainFamily.getText(), s,
1692                                   jTextFieldToolCmd.getText(), jTextFieldTagName.getText(),
1693                                   jTextFieldOptionContents.getText() };
1694                     optionsTableModel.addRow(o);
1695                     docConsole.setSaved(false);
1696                     ffc.genBuildOptionsOpt(stringToVector(jTextFieldBuildTargets.getText()),
1697                                            jTextFieldToolChainFamily.getText(), jTextFieldTagName.getText(),
1698                                            jTextFieldToolCmd.getText(), stringToVector(s),
1699                                            jTextFieldOptionContents.getText());
1700                 }
1701             });
1702         }
1703         return jButtonOptionsAdd;
1704     }
1705
1706     /**
1707      * This method initializes jButtonOptionsDel
1708      *
1709      * Remove a line from the table below
1710      *
1711      * @return javax.swing.JButton  jButtonOptionsDel
1712      */
1713     private JButton getJButtonOptionsDel() {
1714         if (jButtonOptionsDel == null) {
1715             jButtonOptionsDel = new JButton();
1716             jButtonOptionsDel.setText("Delete");
1717             jButtonOptionsDel.setPreferredSize(new java.awt.Dimension(buttonWidth, oneRowHeight));
1718             jButtonOptionsDel.setBounds(new java.awt.Rectangle(next2LastButtonLoc, buttonRow, buttonWidth, oneRowHeight));
1719             jButtonOptionsDel.setLocation(new java.awt.Point(next2LastButtonLoc, buttonRow));
1720             jButtonOptionsDel.addActionListener(new AbstractAction() {
1721                 /**
1722                  *
1723                  */
1724                 private static final long serialVersionUID = 1L;
1725
1726                 public void actionPerformed(java.awt.event.ActionEvent e) {
1727                     if (selectedRow >= 0) {
1728                         optionsTableModel.removeRow(selectedRow);
1729                         docConsole.setSaved(false);
1730                         ffc.removeBuildOptionsOpt(selectedRow);
1731                     }
1732                 }
1733             });
1734         }
1735         return jButtonOptionsDel;
1736     }
1737
1738     public void componentResized(ComponentEvent arg0) {
1739         int intPreferredWidth = 500;
1740
1741         Tools.resizeComponentWidth(this.jScrollPaneOptions, this.getWidth(), intPreferredWidth);
1742
1743     }
1744     /**
1745      * This method initializes jScrollPaneOptions
1746      *  Contains the Table and is located below the data entry section
1747      * @return javax.swing.JScrollPane  jScrollPaneOptoins
1748      */
1749     private JScrollPane getJScrollPaneOptions() {
1750         if (jScrollPaneOptions == null) {
1751             jScrollPaneOptions = new JScrollPane();
1752             jScrollPaneOptions.setViewportView(getJTableOptions());
1753         }
1754         return jScrollPaneOptions;
1755     }
1756
1757     /**
1758      * This method initializes jTableOptions
1759      *
1760      * @return javax.swing.JTable       jTableOptions
1761      */
1762     private JTable getJTableOptions() {
1763         if (jTableOptions == null) {
1764
1765             optionsTableModel = new DefaultTableModel();
1766             jTableOptions = new JTable(optionsTableModel);
1767             jTableOptions.setRowHeight(20);
1768             optionsTableModel.addColumn("Build Targets");
1769             optionsTableModel.addColumn("Tool Chain Family");
1770             optionsTableModel.addColumn("Supported Architectures");
1771             optionsTableModel.addColumn("Tool Command Code");
1772             optionsTableModel.addColumn("TagName");
1773             optionsTableModel.addColumn("Arguments");
1774
1775             jTableOptions.getColumnModel().getColumn(0).setMinWidth(buildTargetWidth);
1776             jTableOptions.getColumnModel().getColumn(1).setMinWidth(toolChainFamilyWidth);
1777             jTableOptions.getColumnModel().getColumn(2).setMinWidth(supportArchWidth);
1778             jTableOptions.getColumnModel().getColumn(3).setMinWidth(toolCmdCodeWidth);
1779             jTableOptions.getColumnModel().getColumn(4).setMinWidth(tagNameWidth);
1780             jTableOptions.getColumnModel().getColumn(5).setMinWidth(argWidth);
1781
1782 //            javax.swing.table.TableColumn toolFamilyCol = jTableOptions.getColumnModel().getColumn(1);
1783 //            JComboBox cb = new JComboBox();
1784 //            cb.addItem("MSFT");
1785 //            cb.addItem("GCC");
1786 //            cb.addItem("CYGWIN");
1787 //            cb.addItem("INTEL");
1788 //            cb.addItem("USER_DEFINED");
1789 //            toolFamilyCol.setCellEditor(new DefaultCellEditor(cb));
1790             Vector<String> vArch = new Vector<String>();
1791             vArch.add("IA32");
1792             vArch.add("X64");
1793             vArch.add("IPF");
1794             vArch.add("EBC");
1795             vArch.add("ARM");
1796             vArch.add("PPC");
1797             jTableOptions.getColumnModel().getColumn(2).setCellEditor(new ListEditor(vArch));
1798
1799             jTableOptions.getColumnModel().getColumn(5).setCellEditor(new LongTextEditor());
1800
1801             jTableOptions.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1802                 jTableOptions.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
1803             jTableOptions.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
1804                 public void valueChanged(ListSelectionEvent e) {
1805                     selectedRow = -1;
1806                     if (e.getValueIsAdjusting()) {
1807                         return;
1808                     }
1809                     ListSelectionModel lsm = (ListSelectionModel) e.getSource();
1810                     if (lsm.isSelectionEmpty()) {
1811                         return;
1812                     } else {
1813                         selectedRow = lsm.getMinSelectionIndex();
1814                     }
1815                 }
1816             });
1817
1818             jTableOptions.getModel().addTableModelListener(new TableModelListener() {
1819                 public void tableChanged(TableModelEvent arg0) {
1820                     // TODO Auto-generated method stub
1821                     int row = arg0.getFirstRow();
1822                     TableModel m = (TableModel) arg0.getSource();
1823                     if (arg0.getType() == TableModelEvent.UPDATE) {
1824                         //ToDo Data Validition check.
1825                         String targets = m.getValueAt(row, 0) + "";
1826                         Vector<Object> targetName = new Vector<Object>();
1827                         String[] sArray = targets.split("( )+");
1828                         for (int i = 0; i < sArray.length; ++i) {
1829                             targetName.add(sArray[i]);
1830                         }
1831                         String toolChain = m.getValueAt(row, 1) + "";
1832                         String archs = m.getValueAt(row, 2) + "";
1833                         Vector<Object> supArch = null;
1834                         if (archs.length() > 0) {
1835                             supArch = new Vector<Object>();
1836                             String[] sArray1 = archs.split("( )+");
1837                             for (int i = 0; i < sArray1.length; ++i) {
1838                                 supArch.add(sArray1[i]);
1839                             }
1840                         }
1841
1842                         String toolCmd = m.getValueAt(row, 3) + "";
1843                         String tagName = m.getValueAt(row, 4) + "";
1844                         String contents = m.getValueAt(row, 5) + "";
1845                         docConsole.setSaved(false);
1846                         ffc.updateBuildOptionsOpt(row, targetName, toolChain, tagName, toolCmd, supArch, contents);
1847                     }
1848                 }
1849             });
1850         }
1851         return jTableOptions;
1852     }
1853
1854     private Vector<Object> stringToVector(String s) {
1855         String[] sArray = s.split(" ");
1856         Vector<Object> v = null;
1857         if (s.length() > 0) {
1858             v = new Vector<Object>();
1859             for (int i = 0; i < sArray.length; ++i) {
1860                 v.add(sArray[i]);
1861             }
1862         }
1863         return v;
1864     }
1865
1866     private String boolToList(boolean[] bool) {
1867         String s = " ";
1868         if (bool[0]) {
1869             s += "IA32 ";
1870         }
1871         if (bool[1]) {
1872             s += "IPF ";
1873         }
1874         if (bool[2]) {
1875             s += "X64 ";
1876         }
1877         if (bool[3]) {
1878             s += "EBC ";
1879         }
1880         if (bool[4]) {
1881             s += "ARM ";
1882         }
1883         if (bool[5]) {
1884             s += "PPC ";
1885         }
1886         if (s.equals(" ")) {
1887             s += "IA32";
1888         }
1889         return s.trim();
1890     }
1891
1892     private void initOptionTable() {
1893         if (ffc.getBuildOptionsOptCount() == 0) {
1894             //ToDo get default options from *.txt file
1895             return;
1896         }
1897         String[][] saa = new String[ffc.getBuildOptionsOptCount()][6];
1898         ffc.getBuildOptionsOpts(saa);
1899         for (int i = 0; i < saa.length; ++i) {
1900             optionsTableModel.addRow(saa[i]);
1901         }
1902     }
1903
1904
1905     /**
1906      * Everything below should pertain to the ANT Task Tab
1907      */
1908
1909     /**
1910      * This method initializes jButton12
1911      *
1912      * @return javax.swing.JButton
1913      */
1914     private JButton getJButtonAntTaskFileBrowse() {
1915         if (jButtonAntTaskFileBrowse == null) {
1916             jButtonAntTaskFileBrowse = new JButton();
1917             jButtonAntTaskFileBrowse.setPreferredSize(new Dimension(buttonWidth, oneRowHeight));
1918             jButtonAntTaskFileBrowse.setText("Browse");
1919             jButtonAntTaskFileBrowse.addActionListener(new AbstractAction() {
1920                 private static final long serialVersionUID = 1L;
1921
1922                 public void actionPerformed(ActionEvent arg0) {
1923                     //
1924                     // Select files from current workspace
1925                     //
1926                     String dirPrefix = System.getenv("WORKSPACE");
1927                     JFileChooser chooser = new JFileChooser(dirPrefix);
1928                     File theFile = null;
1929                     String headerDest = null;
1930
1931                     chooser.setMultiSelectionEnabled(false);
1932                     chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
1933                     int retval = chooser.showOpenDialog(frame);
1934                     if (retval == JFileChooser.APPROVE_OPTION) {
1935
1936                         theFile = chooser.getSelectedFile();
1937                         String file = theFile.getPath();
1938                         if (!file.startsWith(dirPrefix)) {
1939                             JOptionPane.showMessageDialog(frame, "You can only select files in current package!");
1940                             return;
1941                         }
1942                     } else {
1943                         return;
1944                     }
1945
1946                     headerDest = theFile.getPath();
1947                     jTextFieldAntTaskFile.setText(headerDest.substring(dirPrefix.length()).replace('\\', '/'));
1948
1949                 }
1950
1951             });
1952         }
1953         return jButtonAntTaskFileBrowse;
1954     }
1955
1956     /**
1957      * This method initializes jPanelUserDefCenterN
1958      *
1959      * @return javax.swing.JPanel
1960      */
1961     private JPanel getJPanelUserDefCenterN() {
1962         if (jPanelUserDefCenterN == null) {
1963             jPanelUserDefCenterN = new JPanel();
1964             jPanelUserDefCenterN.add(jLabelAntCmdOpts, null);
1965             jPanelUserDefCenterN.add(getJTextFieldAntCmdOpts(), null);
1966             jPanelUserDefCenterN.add(getJButtonAntTaskAdd(), null);
1967             jPanelUserDefCenterN.add(getJButtonAntTaskDel(), null);
1968         }
1969         return jPanelUserDefCenterN;
1970     }
1971
1972     /**
1973      * This method initializes jPanel8
1974      *
1975      * @return javax.swing.JPanel
1976      */
1977     private JPanel getJPanelUserDef() {
1978         if (jPanelUserDef == null) {
1979             jPanelUserDef = new JPanel();
1980             jPanelUserDef.setLayout(new BorderLayout());
1981             jPanelUserDef.add(getJPanelUserDefNorth(), java.awt.BorderLayout.NORTH);
1982             jPanelUserDef.add(getJPanelUserDefCenter(), java.awt.BorderLayout.CENTER);
1983
1984         }
1985         return jPanelUserDef;
1986     }
1987
1988     /**
1989      * This method initializes jPanel9
1990      *
1991      * @return javax.swing.JPanel
1992      */
1993     private JPanel getJPanelUserDefNorth() {
1994         if (jPanelUserDefNorth == null) {
1995             jLabelAntTaskFile = new JLabel();
1996             jLabelAntTaskFile.setText("ANT Task File");
1997             jLabelAntTaskFile.setPreferredSize(new java.awt.Dimension(80, 20));
1998             FlowLayout flowLayout8 = new FlowLayout();
1999             flowLayout8.setAlignment(java.awt.FlowLayout.CENTER);
2000             jLabelAntTaskId = new JLabel();
2001             jLabelAntTaskId.setText("ID");
2002             jPanelUserDefNorth = new JPanel();
2003             jPanelUserDefNorth.setLayout(flowLayout8);
2004             jPanelUserDefNorth.add(jLabelAntTaskFile, null);
2005             jPanelUserDefNorth.add(getJTextFieldAntTaskFile(), null);
2006             jPanelUserDefNorth.add(getJButtonAntTaskFileBrowse(), null);
2007             jPanelUserDefNorth.add(jLabelAntTaskId, null);
2008             jPanelUserDefNorth.add(getJTextFieldAntTaskId(), null);
2009         }
2010         return jPanelUserDefNorth;
2011     }
2012
2013     /**
2014      * This method initializes jPanel11
2015      *
2016      * @return javax.swing.JPanel
2017      */
2018     private JPanel getJPanelUserDefCenter() {
2019         if (jPanelUserDefCenter == null) {
2020             jLabelAntCmdOpts = new JLabel();
2021             jLabelAntCmdOpts.setText("ANT Command Options");
2022             jLabelAntCmdOpts.setPreferredSize(new java.awt.Dimension(131, 20));
2023             jPanelUserDefCenter = new JPanel();
2024             jPanelUserDefCenter.setLayout(new BorderLayout());
2025
2026             jPanelUserDefCenter.add(getJPanelUserDefCenterN(), java.awt.BorderLayout.NORTH);
2027             jPanelUserDefCenter.add(getJScrollPaneAntTasks(), java.awt.BorderLayout.CENTER);
2028         }
2029         return jPanelUserDefCenter;
2030     }
2031
2032     /**
2033      * This method initializes jTextField2
2034      *
2035      * @return javax.swing.JTextField
2036      */
2037     private JTextField getJTextFieldAntTaskFile() {
2038         if (jTextFieldAntTaskFile == null) {
2039             jTextFieldAntTaskFile = new JTextField();
2040             jTextFieldAntTaskFile.setPreferredSize(new java.awt.Dimension(200, 20));
2041         }
2042         return jTextFieldAntTaskFile;
2043     }
2044
2045     /**
2046      * This method initializes jTextField3
2047      *
2048      * @return javax.swing.JTextField
2049      */
2050     private JTextField getJTextFieldAntTaskId() {
2051         if (jTextFieldAntTaskId == null) {
2052             jTextFieldAntTaskId = new JTextField();
2053             jTextFieldAntTaskId.setPreferredSize(new java.awt.Dimension(100, 20));
2054         }
2055         return jTextFieldAntTaskId;
2056     }
2057
2058     /**
2059      * This method initializes jButton4
2060      *
2061      * @return javax.swing.JButton
2062      */
2063     private JButton getJButtonAntTaskAdd() {
2064         if (jButtonAntTaskAdd == null) {
2065             jButtonAntTaskAdd = new JButton();
2066             jButtonAntTaskAdd.setPreferredSize(new java.awt.Dimension(90, 20));
2067             jButtonAntTaskAdd.setText("Add");
2068             jButtonAntTaskAdd.addActionListener(new ActionListener() {
2069                 public void actionPerformed(ActionEvent e) {
2070                     if (!DataValidation.isInt(jTextFieldAntTaskId.getText())
2071                         || jTextFieldAntTaskId.getText().length() != 8) {
2072                         JOptionPane.showMessageDialog(frame, "ID must be an 8-digit integer.");
2073                         return;
2074                     }
2075                     Object[] o = { jTextFieldAntTaskId.getText(), null, null };
2076                     o[1] = jTextFieldAntTaskFile.getText();
2077                     o[2] = jTextFieldAntCmdOpts.getText();
2078                     ffc.genBuildOptionsUserDefAntTask(o[0] + "", o[1] + "", o[2] + "");
2079                     antTaskTableModel.addRow(o);
2080                     docConsole.setSaved(false);
2081                 }
2082             });
2083         }
2084         return jButtonAntTaskAdd;
2085     }
2086
2087     /**
2088      * This method initializes jButton5
2089      *
2090      * @return javax.swing.JButton
2091      */
2092     private JButton getJButtonAntTaskDel() {
2093         if (jButtonAntTaskDel == null) {
2094             jButtonAntTaskDel = new JButton();
2095             jButtonAntTaskDel.setPreferredSize(new java.awt.Dimension(90, 20));
2096             jButtonAntTaskDel.setText("Delete");
2097             jButtonAntTaskDel.addActionListener(new ActionListener() {
2098                 public void actionPerformed(ActionEvent e) {
2099                     if (selectedRow >= 0) {
2100                         docConsole.setSaved(false);
2101                         antTaskTableModel.removeRow(selectedRow);
2102                         ffc.removeBuildOptionsUserDefAntTask(selectedRow);
2103                     }
2104                 }
2105             });
2106         }
2107         return jButtonAntTaskDel;
2108     }
2109
2110     /**
2111      * This method initializes jTextField4
2112      *
2113      * @return javax.swing.JTextField
2114      */
2115     private JTextField getJTextFieldAntCmdOpts() {
2116         if (jTextFieldAntCmdOpts == null) {
2117             jTextFieldAntCmdOpts = new JTextField();
2118             jTextFieldAntCmdOpts.setPreferredSize(new java.awt.Dimension(270, 20));
2119             jTextFieldAntCmdOpts.setEnabled(true);
2120         }
2121         return jTextFieldAntCmdOpts;
2122     }
2123
2124     /**
2125      * This method initializes jScrollPane2
2126      *
2127      * @return javax.swing.JScrollPane
2128      */
2129     private JScrollPane getJScrollPaneAntTasks() {
2130         if (jScrollPaneAntTasks == null) {
2131             jScrollPaneAntTasks = new JScrollPane();
2132             jScrollPaneAntTasks.setPreferredSize(new java.awt.Dimension(600, 400));
2133             jScrollPaneAntTasks.setViewportView(getJTableAntTasks());
2134         }
2135         return jScrollPaneAntTasks;
2136     }
2137
2138     /**
2139      * This method initializes jTable2
2140      *
2141      * @return javax.swing.JTable
2142      */
2143     private JTable getJTableAntTasks() {
2144         if (jTableAntTasks == null) {
2145             antTaskTableModel = new DefaultTableModel();
2146             jTableAntTasks = new JTable(antTaskTableModel);
2147             jTableAntTasks.setRowHeight(20);
2148             antTaskTableModel.addColumn("ID");
2149             antTaskTableModel.addColumn("Filename");
2150             antTaskTableModel.addColumn("ANT Command Options");
2151
2152             jTableAntTasks.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
2153             jTableAntTasks.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
2154                 public void valueChanged(ListSelectionEvent e) {
2155                     selectedRow = -1;
2156                     if (e.getValueIsAdjusting()) {
2157                         return;
2158                     }
2159                     ListSelectionModel lsm = (ListSelectionModel) e.getSource();
2160                     if (lsm.isSelectionEmpty()) {
2161                         return;
2162                     } else {
2163                         selectedRow = lsm.getMinSelectionIndex();
2164                     }
2165                 }
2166             });
2167
2168             jTableAntTasks.getModel().addTableModelListener(new TableModelListener() {
2169                 public void tableChanged(TableModelEvent arg0) {
2170                     // TODO Auto-generated method stub
2171                     int row = arg0.getFirstRow();
2172                     TableModel m = (TableModel) arg0.getSource();
2173                     if (arg0.getType() == TableModelEvent.UPDATE) {
2174                         //ToDo Data Validition check.
2175                         String id = m.getValueAt(row, 0) + "";
2176                         String file = m.getValueAt(row, 1) + "";
2177                         String execOrder = m.getValueAt(row, 2) + "";
2178                         if (id.length() == 0) {
2179                             return;
2180                         }
2181                         if (file.length() == 0 && execOrder.length() == 0) {
2182                             return;
2183                         }
2184                         if (file.length() == 0) {
2185                             file = null;
2186                         }
2187                         if (execOrder.length() == 0) {
2188                             execOrder = null;
2189                         }
2190                         ffc.updateBuildOptionsUserDefAntTask(row, id, file, execOrder);
2191
2192                     }
2193                 }
2194             });
2195         }
2196         return jTableAntTasks;
2197     }
2198
2199     private void initAntTaskTable() {
2200         if (ffc.getBuildOptionsUserDefAntTaskCount() == 0) {
2201             return;
2202         }
2203         String[][] saa = new String[ffc.getBuildOptionsUserDefAntTaskCount()][3];
2204         ffc.getBuildOptionsUserDefAntTasks(saa);
2205         for (int i = 0; i < saa.length; ++i) {
2206             antTaskTableModel.addRow(saa[i]);
2207         }
2208     }
2209
2210 } //  @jve:decl-index=0:visual-constraint="10,10"