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