Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/platform/ui/FpdBuildOptions.java

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