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

   1 /** @file
   2   Java class FpdFlash is GUI for Flash element operation in SPD file.
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13 package org.tianocore.frameworkwizard.platform.ui;
  14
  15 import java.awt.BorderLayout;
  16 import javax.swing.JPanel;
  17
  18 import javax.swing.AbstractAction;
  19 import javax.swing.JFileChooser;
  20 import javax.swing.JFrame;
  21 import javax.swing.JOptionPane;
  22 import javax.swing.JTabbedPane;
  23 import javax.swing.JButton;
  24 import javax.swing.ListSelectionModel;
  25
  26 import org.tianocore.PlatformSurfaceAreaDocument;
  27 import org.tianocore.frameworkwizard.common.DataValidation;
  28 import org.tianocore.frameworkwizard.common.GlobalData;
  29 import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType;
  30 import org.tianocore.frameworkwizard.common.ui.IInternalFrame;
  31 import org.tianocore.frameworkwizard.common.ui.StarLabel;
  32 import org.tianocore.frameworkwizard.module.Identifications.ModuleIdentification;
  33 import org.tianocore.frameworkwizard.platform.ui.FpdFrameworkModules;
  34 import org.tianocore.frameworkwizard.platform.ui.global.WorkspaceProfile;
  35
  36 import java.awt.FlowLayout;
  37 import java.awt.event.ActionEvent;
  38 import java.awt.event.ComponentAdapter;
  39 import java.awt.event.ComponentEvent;
  40 import java.awt.event.ItemEvent;
  41 import java.awt.event.ItemListener;
  42 import java.io.BufferedReader;
  43 import java.io.File;
  44 import java.io.FileReader;
  45 import java.util.ArrayList;
  46 import java.util.HashMap;
  47 import java.util.Iterator;
  48 import java.util.LinkedHashMap;
  49 import java.util.Map;
  50 import java.util.Set;
  51 import java.util.Vector;
  52
  53 import javax.swing.JCheckBox;
  54 import javax.swing.JTextField;
  55 import java.awt.GridLayout;
  56 import javax.swing.JLabel;
  57 import javax.swing.JScrollPane;
  58 import javax.swing.JTable;
  59 import javax.swing.event.InternalFrameAdapter;
  60 import javax.swing.event.InternalFrameEvent;
  61 import javax.swing.event.ListSelectionEvent;
  62 import javax.swing.event.ListSelectionListener;
  63 import javax.swing.event.TableModelEvent;
  64 import javax.swing.event.TableModelListener;
  65 import javax.swing.table.DefaultTableModel;
  66 import javax.swing.table.TableModel;
  67 import javax.swing.JComboBox;
  68 import java.awt.Dimension;
  69 import javax.swing.JSplitPane;
  70
  71 public class FpdFlash extends IInternalFrame {
  72
  73     /**
  74      *
  75      */
  76     private static final long serialVersionUID = 1L;
  77     private final int startIndexOfDynamicTab = 2;
  78     static JFrame frame;
  79     private JPanel jContentPane = null;
  80     private JPanel jPanelContentEast = null;
  81     private JPanel jPanelContentSouth = null;
  82     private JPanel jPanelContentWest = null;
  83     private JPanel jPanelContentNorth = null;
  84     private JTabbedPane jTabbedPane = null;
  85     private JPanel jPanelFvImages = null;
  86     private JPanel jPanelFvImageN = null;
  87     private JPanel jPanelFvImageS = null;
  88     private JCheckBox jCheckBoxFvProperty = null;
  89     private JLabel jLabelFvPropName = null;
  90     private JTextField jTextFieldFvPropName = null;
  91     private JLabel jLabelFvPropValue = null;
  92     private JTextField jTextFieldFvPropValue = null;
  93     private JButton jButtonFvPropAdd = null;
  94     private JScrollPane jScrollPaneFvProp = null;
  95     private JTable jTableFvProp = null;
  96     private JPanel jPanelFvPropButtonGroup = null;
  97     private JButton jButtonFvPropDel = null;
  98     private DefaultTableModel fvPropertyTableModel = null;
  99     private DefaultTableModel fvImageNameTableModel = null;
 100     private ImageParaTableModel fvImageParaTableModel = null;
 101     private DefaultTableModel fvOptionTableModel = null;
 102     private JPanel jPanelFvImageC = null;
 103     private JLabel jLabelFvParaType = null;
 104     private JComboBox jComboBoxFvParaType = null;
 105     private JLabel jLabelFvImageNames = null;
 106     private JLabel jLabelFvParaName = null;
 107     private JTextField jTextFieldFvParaName = null;
 108     private JButton jButtonFvNameAdd = null;
 109     private JScrollPane jScrollPaneFvImageNames = null;
 110     private JTable jTableFvImageNames = null;
 111     private JButton jButtonFvNameDel = null;
 112     private JPanel jPanelFvImageOpts = null;
 113     private JButton jButtonAddFvImage = null;
 114     private JScrollPane jScrollPaneFvInfo = null;
 115     private JTable jTableFvInfo = null;
 116     private JButton jButtonDelFvImage = null;
 117     private JPanel jPanelFvImagePara = null;
 118     private OpeningPlatformType docConsole = null;
 119     private FpdFileContents ffc = null;
 120     private JPanel jPanelFdf = null;
 121     private JCheckBox jCheckBoxFdf = null;
 122     private JTextField jTextFieldFdf = null;
 123     private JButton jButtonFdfBrowse = null;
 124     private JLabel jLabelFvImageOptName = null;
 125     private JTextField jTextFieldFvImageOptName = null;
 126     private JLabel jLabelFvImageOptValue = null;
 127     private JTextField jTextFieldFvImageOptValue = null;
 128     private JPanel jPanelFvImageOptsButtonGroup = null;
 129     private JButton jButtonFvImageOptAdd = null;
 130     private JButton jButtonFvImageOptDel = null;
 131     private JScrollPane jScrollPane = null;
 132     private JTable jTableFvImageOpts = null;
 133     private JButton jButtonUpdateFvImage = null;
 134     private JPanel jPanelFdfN = null;
 135     private JPanel jPanelFdfS = null;
 136     private JSplitPane jSplitPaneFdfC = null;
 137     private JPanel jPanelFdfCTop = null;
 138     private JPanel jPanelFdfCBottom = null;
 139     private JPanel jPanelFdfCTopN = null;
 140     private JPanel jPanelFdfCTopS = null;
 141     private JPanel jPanelFdfCTopC = null;
 142     private JPanel jPanelFdfCBottomN = null;
 143     private JPanel jPanelFdfCBottomC = null;
 144     private JLabel jLabelFvInFdf = null;
 145     private JLabel jLabelFvAdditional = null;
 146     private JScrollPane jScrollPaneFvInFdf = null;
 147     private JTable jTableFvInFdf = null;
 148     private NonEditableTableModel fvInFdfTableModel = null;  //  @jve:decl-index=0:visual-constraint=""
 149     private JButton jButtonFvInFdfOptions = null;
 150     private JScrollPane jScrollPaneFvAdditional = null;
 151     private JTable jTableFvAdditional = null;
 152     private DefaultTableModel fvAdditionalTableModel = null;  //  @jve:decl-index=0:visual-constraint=""
 153     private JButton jButtonAddFv = null;
 154     private JButton jButtonDelFv = null;
 155     private JButton jButtonAddFvOptions = null;
 156     private int tabIndexForFv = -1;
 157     private int selectedRowInFvAdditionalTable = -1;
 158     private String oldFvName = null;
 159     private Vector<String> vBlockSize = new Vector<String>();
 160     private String determinedFvBlockSize = null;
 161     private final String defaultBlkSize = "0x10000";
 162     private String erasePolarity = "";
 163     boolean memModified = false;
 164     private FvOptsTableModel fvInFdfOptTableModel = null;
 165     private FvOptsTableModel fvAdditionalOptTableModel = null;
 166     private boolean sizeFromOptionDlg = false;
 167     private boolean fileFromOptionDlg = false;
 168     private JLabel jLabelOptions = null;
 169     private JPanel jPanelBgFvName = null;
 170     private JPanel jPanelBgFvImage = null;
 171     private JPanel jPanelW = null;
 172     private String oldFvNameInFvImage = "";
 173
 174     public FpdFlash() {
 175         super();
 176         // TODO Auto-generated constructor stub
 177
 178         initialize();
 179         this.setBounds(new java.awt.Rectangle(0, 0, 500, 370));
 180         this.setVisible(true);
 181     }
 182
 183     public FpdFlash(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd){
 184         this();
 185         ffc = new FpdFileContents(fpd);
 186         init(ffc);
 187     }
 188
 189     public FpdFlash(OpeningPlatformType opt) {
 190         this(opt.getXmlFpd());
 191         docConsole = opt;
 192         if (memModified) {
 193             docConsole.setSaved(false);
 194             JOptionPane.showMessageDialog(frame, "Platform Synced with FDF file.");
 195             memModified = false;
 196         }
 197     }
 198
 199     /**
 200      * This method initializes jPanel
 201      *
 202      * @return javax.swing.JPanel
 203      */
 204     private JPanel getJPanelContentEast() {
 205         if (jPanelContentEast == null) {
 206             FlowLayout flowLayout7 = new FlowLayout();
 207             flowLayout7.setVgap(50);
 208             jPanelContentEast = new JPanel();
 209             jPanelContentEast.setLayout(flowLayout7);
 210         }
 211         return jPanelContentEast;
 212     }
 213
 214     /**
 215      * This method initializes jPanel1
 216      *
 217      * @return javax.swing.JPanel
 218      */
 219     private JPanel getJPanelContentSouth() {
 220         if (jPanelContentSouth == null) {
 221             FlowLayout flowLayout = new FlowLayout();
 222             flowLayout.setAlignment(java.awt.FlowLayout.RIGHT);
 223             flowLayout.setHgap(15);
 224             jPanelContentSouth = new JPanel();
 225             jPanelContentSouth.setLayout(flowLayout);
 226             jPanelContentSouth.setComponentOrientation(java.awt.ComponentOrientation.LEFT_TO_RIGHT);
 227         }
 228         return jPanelContentSouth;
 229     }
 230
 231     /**
 232      * This method initializes jPanel2
 233      *
 234      * @return javax.swing.JPanel
 235      */
 236     private JPanel getJPanelContentWest() {
 237         if (jPanelContentWest == null) {
 238             jPanelContentWest = new JPanel();
 239         }
 240         return jPanelContentWest;
 241     }
 242
 243     /**
 244      * This method initializes jPanel3
 245      *
 246      * @return javax.swing.JPanel
 247      */
 248     private JPanel getJPanelContentNorth() {
 249         if (jPanelContentNorth == null) {
 250             jPanelContentNorth = new JPanel();
 251         }
 252         return jPanelContentNorth;
 253     }
 254
 255     /**
 256      * This method initializes jTabbedPane
 257      *
 258      * @return javax.swing.JTabbedPane
 259      */
 260     private JTabbedPane getJTabbedPane() {
 261         if (jTabbedPane == null) {
 262             jTabbedPane = new JTabbedPane();
 263             jTabbedPane.addTab("General", null, getJPanelFdf(), null);
 264             jTabbedPane.addTab("Advanced", null, getJPanelFvImages(), null);
 265
 266         }
 267         return jTabbedPane;
 268     }
 269
 270     /**
 271      * This method initializes jPanelFvImages
 272      *
 273      * @return javax.swing.JPanel
 274      */
 275     private JPanel getJPanelFvImages() {
 276         if (jPanelFvImages == null) {
 277             jPanelFvImages = new JPanel();
 278             jPanelFvImages.setLayout(new BorderLayout());
 279             jPanelFvImages.add(getJPanelFvImageS(), java.awt.BorderLayout.NORTH);
 280             jPanelFvImages.add(getJPanelFvImageN(), java.awt.BorderLayout.SOUTH);
 281             jPanelFvImages.add(getJPanelFvImageC(), java.awt.BorderLayout.CENTER);
 282             jPanelFvImages.add(getJPanelW(), java.awt.BorderLayout.EAST);
 283             jPanelFvImages.addComponentListener(new java.awt.event.ComponentAdapter() {
 284                 public void componentShown(java.awt.event.ComponentEvent e) {
 285 //                    fvImageParaTableModel.setRowCount(0);
 286 //                    fvPropertyTableModel.setRowCount(0);
 287
 288
 289                 }
 290             });
 291
 292         }
 293         return jPanelFvImages;
 294     }
 295
 296     /**
 297      * This method initializes jPanelFvImageN
 298      *
 299      * @return javax.swing.JPanel
 300      */
 301     private JPanel getJPanelFvImageN() {
 302         if (jPanelFvImageN == null) {
 303             jLabelFvPropValue = new JLabel();
 304             jLabelFvPropValue.setText("Value");
 305             jLabelFvPropValue.setEnabled(false);
 306             jLabelFvPropValue.setPreferredSize(new java.awt.Dimension(38,20));
 307             jLabelFvPropName = new JLabel();
 308             jLabelFvPropName.setText("Name");
 309             jLabelFvPropName.setEnabled(false);
 310             jLabelFvPropName.setPreferredSize(new java.awt.Dimension(38,20));
 311             FlowLayout flowLayout2 = new FlowLayout();
 312             flowLayout2.setAlignment(java.awt.FlowLayout.LEFT);
 313             flowLayout2.setHgap(5);
 314             jPanelFvImageN = new JPanel();
 315             jPanelFvImageN.setPreferredSize(new java.awt.Dimension(576,130));
 316             jPanelFvImageN.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
 317             jPanelFvImageN.setLayout(flowLayout2);
 318             jPanelFvImageN.add(getJCheckBoxFvProperty(), null);
 319             jPanelFvImageN.add(jLabelFvPropName, null);
 320             jPanelFvImageN.add(getJTextFieldFvPropName(), null);
 321             jPanelFvImageN.add(jLabelFvPropValue, null);
 322             jPanelFvImageN.add(getJTextFieldFvPropValue(), null);
 323             jPanelFvImageN.add(getJScrollPaneFvProp(), null);
 324             jPanelFvImageN.add(getJPanelFvPropButtonGroup(), null);
 325         }
 326         return jPanelFvImageN;
 327     }
 328
 329     /**
 330      * This method initializes jPanelFvImageS
 331      *
 332      * @return javax.swing.JPanel
 333      */
 334     private JPanel getJPanelFvImageS() {
 335         if (jPanelFvImageS == null) {
 336             GridLayout gridLayout2 = new GridLayout();
 337             gridLayout2.setRows(1);
 338             jPanelFvImageS = new JPanel();
 339             jPanelFvImageS.setPreferredSize(new java.awt.Dimension(480,150));
 340             jPanelFvImageS.setLayout(gridLayout2);
 341             jPanelFvImageS.add(getJScrollPaneFvInfo(), null);
 342         }
 343         return jPanelFvImageS;
 344     }
 345
 346
 347     /**
 348      * This method initializes jCheckBox1
 349      *
 350      * @return javax.swing.JCheckBox
 351      */
 352     private JCheckBox getJCheckBoxFvProperty() {
 353         if (jCheckBoxFvProperty == null) {
 354             jCheckBoxFvProperty = new JCheckBox();
 355             jCheckBoxFvProperty.setText("Global FV Variables");
 356             jCheckBoxFvProperty.addItemListener(new ItemListener(){
 357
 358                 public void itemStateChanged(ItemEvent arg0) {
 359                     // TODO Auto-generated method stub
 360                     boolean seleted = jCheckBoxFvProperty.isSelected();
 361
 362                         jLabelFvPropName.setEnabled(seleted);
 363                         jTextFieldFvPropName.setEnabled(seleted);
 364                         jLabelFvPropValue.setEnabled(seleted);
 365                         jTextFieldFvPropValue.setEnabled(seleted);
 366                         jTableFvProp.setEnabled(seleted);
 367                         jButtonFvPropAdd.setEnabled(seleted);
 368                         jButtonFvPropDel.setEnabled(seleted);
 369
 370
 371                 }
 372
 373             });
 374         }
 375         return jCheckBoxFvProperty;
 376     }
 377
 378
 379     /**
 380      * This method initializes jTextField
 381      *
 382      * @return javax.swing.JTextField
 383      */
 384     private JTextField getJTextFieldFvPropName() {
 385         if (jTextFieldFvPropName == null) {
 386             jTextFieldFvPropName = new JTextField();
 387             jTextFieldFvPropName.setPreferredSize(new java.awt.Dimension(100,20));
 388             jTextFieldFvPropName.setEnabled(false);
 389         }
 390         return jTextFieldFvPropName;
 391     }
 392
 393
 394     /**
 395      * This method initializes jTextField1
 396      *
 397      * @return javax.swing.JTextField
 398      */
 399     private JTextField getJTextFieldFvPropValue() {
 400         if (jTextFieldFvPropValue == null) {
 401             jTextFieldFvPropValue = new JTextField();
 402             jTextFieldFvPropValue.setPreferredSize(new java.awt.Dimension(100,20));
 403             jTextFieldFvPropValue.setEnabled(false);
 404         }
 405         return jTextFieldFvPropValue;
 406     }
 407
 408
 409     /**
 410      * This method initializes jButton
 411      *
 412      * @return javax.swing.JButton
 413      */
 414     private JButton getJButtonFvPropAdd() {
 415         if (jButtonFvPropAdd == null) {
 416             jButtonFvPropAdd = new JButton();
 417             jButtonFvPropAdd.setPreferredSize(new java.awt.Dimension(80,20));
 418             jButtonFvPropAdd.setEnabled(false);
 419             jButtonFvPropAdd.setText("Add");
 420             jButtonFvPropAdd.addActionListener(new AbstractAction() {
 421                 /**
 422                  *
 423                  */
 424                 private static final long serialVersionUID = 1L;
 425
 426                 public void actionPerformed(ActionEvent e) {
 427                     if (jTextFieldFvPropName.getText().length() > 0 && jTextFieldFvPropValue.getText().length() > 0){
 428                         String[] row = {jTextFieldFvPropName.getText(), jTextFieldFvPropValue.getText()};
 429                         fvPropertyTableModel.addRow(row);
 430                         docConsole.setSaved(false);
 431                         ffc.genFvImagesNameValue(row[0], row[1]);
 432                     }
 433                 }
 434             });
 435         }
 436         return jButtonFvPropAdd;
 437     }
 438
 439
 440     /**
 441      * This method initializes jScrollPane1
 442      *
 443      * @return javax.swing.JScrollPane
 444      */
 445     private JScrollPane getJScrollPaneFvProp() {
 446         if (jScrollPaneFvProp == null) {
 447             jScrollPaneFvProp = new JScrollPane();
 448             jScrollPaneFvProp.setPreferredSize(new java.awt.Dimension(350,100));
 449             jScrollPaneFvProp.setViewportView(getJTableFvProp());
 450         }
 451         return jScrollPaneFvProp;
 452     }
 453
 454
 455     /**
 456      * This method initializes jTable
 457      *
 458      * @return javax.swing.JTable
 459      */
 460     private JTable getJTableFvProp() {
 461         if (jTableFvProp == null) {
 462             fvPropertyTableModel = new DefaultTableModel();
 463             jTableFvProp = new JTable(fvPropertyTableModel);
 464             fvPropertyTableModel.addColumn("Name");
 465             fvPropertyTableModel.addColumn("Value");
 466             jTableFvProp.setRowHeight(20);
 467             jTableFvProp.setEnabled(false);
 468
 469             jTableFvProp.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 470             jTableFvProp.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 471                 public void valueChanged(ListSelectionEvent e) {
 472                     if (e.getValueIsAdjusting()){
 473                         return;
 474                     }
 475                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 476                     if (lsm.isSelectionEmpty()) {
 477                         return;
 478                     }
 479                     else{
 480 //                        selectedRow = lsm.getMinSelectionIndex();
 481                     }
 482                 }
 483             });
 484
 485             jTableFvProp.getModel().addTableModelListener(new TableModelListener(){
 486                 public void tableChanged(TableModelEvent arg0) {
 487                     // TODO Auto-generated method stub
 488                     int row = arg0.getFirstRow();
 489                     TableModel m = (TableModel)arg0.getSource();
 490                     if (arg0.getType() == TableModelEvent.UPDATE){
 491
 492                         String name = m.getValueAt(row, 0) + "";
 493                         String value = m.getValueAt(row, 1) + "";
 494                         docConsole.setSaved(false);
 495                         ffc.updateFvImagesNameValue(row, name, value);
 496                     }
 497                 }
 498             });
 499         }
 500         return jTableFvProp;
 501     }
 502
 503
 504     /**
 505      * This method initializes jPanel4
 506      *
 507      * @return javax.swing.JPanel
 508      */
 509     private JPanel getJPanelFvPropButtonGroup() {
 510         if (jPanelFvPropButtonGroup == null) {
 511             jPanelFvPropButtonGroup = new JPanel();
 512             jPanelFvPropButtonGroup.setPreferredSize(new java.awt.Dimension(80,55));
 513
 514             jPanelFvPropButtonGroup.add(getJButtonFvPropAdd(), null);
 515             jPanelFvPropButtonGroup.add(getJButtonFvPropDel(), null);
 516         }
 517         return jPanelFvPropButtonGroup;
 518     }
 519
 520
 521     /**
 522      * This method initializes jButton1
 523      *
 524      * @return javax.swing.JButton
 525      */
 526     private JButton getJButtonFvPropDel() {
 527         if (jButtonFvPropDel == null) {
 528             jButtonFvPropDel = new JButton();
 529             jButtonFvPropDel.setPreferredSize(new java.awt.Dimension(80,20));
 530             jButtonFvPropDel.setEnabled(false);
 531             jButtonFvPropDel.setText("Delete");
 532             jButtonFvPropDel.addActionListener(new AbstractAction() {
 533                 /**
 534                  *
 535                  */
 536                 private static final long serialVersionUID = 1L;
 537
 538                 public void actionPerformed(ActionEvent e) {
 539                     if (jTableFvProp.getSelectedRow() >= 0){
 540                         fvPropertyTableModel.removeRow(jTableFvProp.getSelectedRow());
 541                         docConsole.setSaved(false);
 542                         ffc.removeFvImagesNameValue(jTableFvProp.getSelectedRow());
 543                     }
 544                 }
 545             });
 546         }
 547         return jButtonFvPropDel;
 548     }
 549
 550
 551     /**
 552      * This method initializes jPanelFvImageC
 553      *
 554      * @return javax.swing.JPanel
 555      */
 556     private JPanel getJPanelFvImageC() {
 557         if (jPanelFvImageC == null) {
 558             jLabelFvParaName = new JLabel();
 559             jLabelFvParaName.setPreferredSize(new Dimension(38, 20));
 560             jLabelFvParaName.setText("Name");
 561             jLabelFvImageNames = new JLabel();
 562             jLabelFvImageNames.setText("FV Image Names");
 563             jLabelFvImageNames.setPreferredSize(new java.awt.Dimension(150,20));
 564             jLabelFvParaType = new JLabel();
 565             jLabelFvParaType.setText("Type");
 566             jLabelFvParaType.setPreferredSize(new java.awt.Dimension(70,20));
 567             FlowLayout flowLayout3 = new FlowLayout();
 568             flowLayout3.setAlignment(java.awt.FlowLayout.LEFT);
 569             flowLayout3.setHgap(5);
 570             jPanelFvImageC = new JPanel();
 571             jPanelFvImageC.setLayout(flowLayout3);
 572             jPanelFvImageC.add(getJPanelFvImagePara(), null);
 573
 574             jPanelFvImageC.add(getJPanelFvImageOpts(), null);
 575
 576         }
 577         return jPanelFvImageC;
 578     }
 579
 580
 581     /**
 582      * This method initializes jComboBox
 583      *
 584      * @return javax.swing.JComboBox
 585      */
 586     private JComboBox getJComboBoxFvParaType() {
 587         if (jComboBoxFvParaType == null) {
 588             jComboBoxFvParaType = new JComboBox();
 589             jComboBoxFvParaType.addItem("Attributes");
 590             jComboBoxFvParaType.addItem("Components");
 591             jComboBoxFvParaType.setSelectedIndex(0);
 592             jComboBoxFvParaType.setPreferredSize(new java.awt.Dimension(180,20));
 593             jComboBoxFvParaType.addItemListener(new ItemListener() {
 594
 595                 public void itemStateChanged(ItemEvent arg0) {
 596                     // TODO disable attribute settings when ValidImageNames selected.
 597                     int selectedRow = jTableFvInfo.getSelectedRow();
 598                     if (selectedRow < 0) {
 599                         return;
 600                     }
 601                     String fvNameList = jTableFvInfo.getValueAt(selectedRow, 0)+"";
 602                     String oldType = jTableFvInfo.getValueAt(selectedRow, 1)+"";
 603                     int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, oldType);
 604                     if (fvImagePos < 0) {
 605                         return;
 606                     }
 607
 608                     String type = jComboBoxFvParaType.getSelectedItem()+"";
 609                     ffc.updateFvImagesFvImageType(fvImagePos, type);
 610                     jTableFvInfo.setValueAt(type, selectedRow, 1);
 611                     docConsole.setSaved(false);
 612                 }
 613
 614             });
 615         }
 616         return jComboBoxFvParaType;
 617     }
 618
 619
 620     /**
 621      * This method initializes jTextField2
 622      *
 623      * @return javax.swing.JTextField
 624      */
 625     private JTextField getJTextFieldFvParaName() {
 626         if (jTextFieldFvParaName == null) {
 627             jTextFieldFvParaName = new JTextField();
 628             jTextFieldFvParaName.setPreferredSize(new java.awt.Dimension(140,20));
 629         }
 630         return jTextFieldFvParaName;
 631     }
 632
 633
 634     /**
 635      * This method initializes jButton2
 636      *
 637      * @return javax.swing.JButton
 638      */
 639     private JButton getJButtonFvNameAdd() {
 640         if (jButtonFvNameAdd == null) {
 641             jButtonFvNameAdd = new JButton();
 642             jButtonFvNameAdd.setPreferredSize(new Dimension(80, 20));
 643             jButtonFvNameAdd.setEnabled(true);
 644             jButtonFvNameAdd.setText("Add");
 645             jButtonFvNameAdd.addActionListener(new AbstractAction() {
 646                 /**
 647                  *
 648                  */
 649                 private static final long serialVersionUID = 1L;
 650
 651                 public void actionPerformed(java.awt.event.ActionEvent e) {
 652                     if (jTextFieldFvParaName.getText().length() > 0){
 653                         String[] row = {jTextFieldFvParaName.getText()};
 654                         int selectedRow = jTableFvInfo.getSelectedRow();
 655                         if (selectedRow < 0) {
 656                             return;
 657                         }
 658
 659                         String fvNameList = jTableFvInfo.getValueAt(selectedRow, 0)+"";
 660                         String type = jTableFvInfo.getValueAt(selectedRow, 1)+"";
 661                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, type);
 662
 663                         if (fvImagePos < 0) {
 664                           // new FvImage.
 665                             ffc.genFvImagesFvImage(row, jComboBoxFvParaType.getSelectedItem()+"", null);
 666                         }
 667                         else {
 668                           //append Fv name.
 669                           ffc.addFvImageNamesInFvImage(fvImagePos, row);
 670                         }
 671                         docConsole.setSaved(false);
 672                         fvImageNameTableModel.addRow(row);
 673                         fvNameList += " ";
 674                         fvNameList += row[0];
 675                         jTableFvInfo.setValueAt(fvNameList.trim(), selectedRow, 0);
 676                         jTableFvImageNames.changeSelection(jTableFvImageNames.getRowCount() - 1, 0, false, false);
 677                     }
 678                 }
 679             });
 680         }
 681         return jButtonFvNameAdd;
 682     }
 683
 684
 685     /**
 686      * This method initializes jScrollPane2
 687      *
 688      * @return javax.swing.JScrollPane
 689      */
 690     private JScrollPane getJScrollPaneFvImageNames() {
 691         if (jScrollPaneFvImageNames == null) {
 692             jScrollPaneFvImageNames = new JScrollPane();
 693             jScrollPaneFvImageNames.setPreferredSize(new java.awt.Dimension(350,80));
 694             jScrollPaneFvImageNames.setViewportView(getJTableFvImageNames());
 695         }
 696         return jScrollPaneFvImageNames;
 697     }
 698
 699
 700     /**
 701      * This method initializes jTable1
 702      *
 703      * @return javax.swing.JTable
 704      */
 705     private JTable getJTableFvImageNames() {
 706         if (jTableFvImageNames == null) {
 707             fvImageNameTableModel = new NonEditableTableModel();
 708             jTableFvImageNames = new JTable(fvImageNameTableModel);
 709             jTableFvImageNames.setRowHeight(20);
 710             fvImageNameTableModel.addColumn("FV Image Name");
 711
 712         }
 713         return jTableFvImageNames;
 714     }
 715
 716
 717     /**
 718      * This method initializes jButton3
 719      *
 720      * @return javax.swing.JButton
 721      */
 722     private JButton getJButtonFvNameDel() {
 723         if (jButtonFvNameDel == null) {
 724             jButtonFvNameDel = new JButton();
 725             jButtonFvNameDel.setPreferredSize(new Dimension(80, 20));
 726             jButtonFvNameDel.setEnabled(true);
 727             jButtonFvNameDel.setText("Delete");
 728             jButtonFvNameDel.addActionListener(new AbstractAction() {
 729                 /**
 730                  *
 731                  */
 732                 private static final long serialVersionUID = 1L;
 733
 734                 public void actionPerformed(java.awt.event.ActionEvent e) {
 735                     if (jTableFvImageNames.getSelectedRow() >= 0){
 736                         int selectedRow = jTableFvInfo.getSelectedRow();
 737                         if (selectedRow < 0) {
 738                             return;
 739                         }
 740
 741                         String selectedFvName = jTableFvImageNames.getValueAt(jTableFvImageNames.getSelectedRow(), 0)+"";
 742                         String fvNameList = jTableFvInfo.getValueAt(selectedRow, 0)+"";
 743                         String type = jTableFvInfo.getValueAt(selectedRow, 1)+"";
 744                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, type);
 745
 746                         if (fvImagePos < 0) {
 747                             return;
 748                         }
 749                         else {
 750                           //delete Fv name.
 751                             ffc.updateFvImageNamesInFvImage(fvImagePos, selectedFvName, null);
 752                         }
 753                         docConsole.setSaved(false);
 754                         String newList = removeFvNameFromList(fvNameList, selectedFvName);
 755                         jTableFvInfo.setValueAt(newList, selectedRow, 0);
 756                         fvImageNameTableModel.removeRow(jTableFvImageNames.getSelectedRow());
 757                     }
 758                 }
 759             });
 760         }
 761         return jButtonFvNameDel;
 762     }
 763
 764   private String removeFvNameFromList (String list, String name) {
 765       String[] nameArray = list.split(" ");
 766       int occursAt = -1;
 767       for (int i = 0; i < nameArray.length; ++i) {
 768           if (nameArray[i].equals(name)) {
 769               occursAt = i;
 770               break;
 771           }
 772       }
 773
 774       if (occursAt == -1) {
 775           return list;
 776       }
 777
 778       String newList = " ";
 779       for (int j = 0; j < nameArray.length; ++j) {
 780           if (j != occursAt) {
 781               newList += nameArray[j];
 782               newList += " ";
 783           }
 784       }
 785
 786       return newList.trim();
 787   }
 788
 789
 790   private JPanel getJPanelFvImageOpts() {
 791
 792
 793  if (jPanelFvImageOpts == null) {
 794      //ToDo add ButtonGroup for RadioButtons
 795             FlowLayout flowLayout5 = new FlowLayout();
 796             flowLayout5.setAlignment(java.awt.FlowLayout.LEFT);
 797             jLabelOptions = new JLabel();
 798             jLabelOptions.setText("Attribute");
 799             jLabelFvImageOptValue = new JLabel();
 800             jLabelFvImageOptValue.setEnabled(true);
 801             jLabelFvImageOptValue.setText("Value");
 802             jLabelFvImageOptValue.setPreferredSize(new Dimension(38, 20));
 803             jLabelFvImageOptName = new JLabel();
 804             jLabelFvImageOptName.setEnabled(true);
 805             jLabelFvImageOptName.setText("Name");
 806             jLabelFvImageOptName.setPreferredSize(new Dimension(38, 20));
 807             jPanelFvImageOpts = new JPanel();
 808             jPanelFvImageOpts.setLayout(flowLayout5);
 809             jPanelFvImageOpts.setPreferredSize(new java.awt.Dimension(450,130));
 810
 811
 812                         jPanelFvImageOpts.setBorder(javax.swing.BorderFactory.createEtchedBorder(javax.swing.border.EtchedBorder.LOWERED));
 813                         jPanelFvImageOpts.add(jLabelOptions, null);
 814                         jPanelFvImageOpts.add(jLabelFvImageOptName, null);
 815                         jPanelFvImageOpts.add(getJTextFieldFvImageOptName(), null);
 816                         jPanelFvImageOpts.add(jLabelFvImageOptValue, null);
 817                         jPanelFvImageOpts.add(getJTextFieldFvImageOptValue(), null);
 818                         jPanelFvImageOpts.add(getJScrollPane(), null);
 819                         jPanelFvImageOpts.add(getJPanelFvImageOptsButtonGroup(), null);
 820
 821
 822
 823
 824
 825         }
 826         return jPanelFvImageOpts;
 827     }
 828
 829
 830     /**
 831      * This method initializes jButton4
 832      *
 833      * @return javax.swing.JButton
 834      */
 835     private JButton getJButtonAddFvImage() {
 836         if (jButtonAddFvImage == null) {
 837             jButtonAddFvImage = new JButton();
 838             jButtonAddFvImage.setPreferredSize(new java.awt.Dimension(150,20));
 839             jButtonAddFvImage.setText("New FV Attributes");
 840             jButtonAddFvImage.addActionListener(new AbstractAction() {
 841                 /**
 842                  *
 843                  */
 844                 private static final long serialVersionUID = 1L;
 845
 846                 public void actionPerformed(java.awt.event.ActionEvent e) {
 847
 848 //                    String imageName = " ";
 849 //                    for (int i = 0; i < jTableFvImageNames.getRowCount(); ++i){
 850 //                        imageName += (String)jTableFvImageNames.getValueAt(i, 0);
 851 //                        imageName += " ";
 852 //                    }
 853 //                    imageName = imageName.trim();
 854
 855 //                    LinkedHashMap<String, String> m = null;
 856 //                    m = new LinkedHashMap<String, String>();
 857 //                    getOptionNameValue(m);
 858 //                    ffc.genFvImagesFvImage(imageName.split(" "), jComboBoxFvParaType.getSelectedItem()+"", m);
 859 //                    docConsole.setSaved(false);
 860                     fvImageNameTableModel.setRowCount(0);
 861                     fvOptionTableModel.setRowCount(0);
 862                     Object[] row = {"", jComboBoxFvParaType.getSelectedItem()};
 863                     fvImageParaTableModel.addRow(row);
 864                     jTableFvInfo.changeSelection(jTableFvInfo.getRowCount() - 1, 0, false, false);
 865                 }
 866             });
 867         }
 868         return jButtonAddFvImage;
 869     }
 870
 871
 872     /**
 873      * This method initializes jScrollPane3
 874      *
 875      * @return javax.swing.JScrollPane
 876      */
 877     private JScrollPane getJScrollPaneFvInfo() {
 878         if (jScrollPaneFvInfo == null) {
 879             jScrollPaneFvInfo = new JScrollPane();
 880             jScrollPaneFvInfo.setPreferredSize(new java.awt.Dimension(480,150));
 881             jScrollPaneFvInfo.setViewportView(getJTableFvInfo());
 882         }
 883         return jScrollPaneFvInfo;
 884     }
 885
 886
 887     /**
 888      * This method initializes jTable2
 889      *
 890      * @return javax.swing.JTable
 891      */
 892     private JTable getJTableFvInfo() {
 893         if (jTableFvInfo == null) {
 894             fvImageParaTableModel = new ImageParaTableModel();
 895             jTableFvInfo = new JTable(fvImageParaTableModel);
 896             fvImageParaTableModel.addColumn("FvImageNames");
 897             fvImageParaTableModel.addColumn("Type");
 898
 899             jTableFvInfo.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 900             jTableFvInfo.setRowHeight(20);
 901             jTableFvInfo.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 902                 public void valueChanged(ListSelectionEvent e) {
 903                     if (e.getValueIsAdjusting()){
 904                         return;
 905                     }
 906                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 907                     if (lsm.isSelectionEmpty()) {
 908                         return;
 909                     }
 910                     else{
 911                         int selectedRow = lsm.getMinSelectionIndex();
 912                         String fvNameList = fvImageParaTableModel.getValueAt(selectedRow, 0)+"";
 913                         String type = fvImageParaTableModel.getValueAt(selectedRow, 1)+"";
 914                         jComboBoxFvParaType.setSelectedItem(type);
 915                         String[] fvNames = fvNameList.split(" ");
 916                         fvImageNameTableModel.setRowCount(0);
 917                         fvOptionTableModel.setRowCount(0);
 918                         for (int i = 0; i < fvNames.length; ++i) {
 919                             String[] row = { fvNames[i] };
 920                             if (row[0].length() > 0) {
 921                                 fvImageNameTableModel.addRow(row);
 922                             }
 923                         }
 924
 925                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, type);
 926                         if (fvImagePos < 0) {
 927                             return;
 928                         }
 929                         LinkedHashMap<String, String> optionMap = new LinkedHashMap<String, String>();
 930                         ffc.getFvImagesFvImageOptions(fvImagePos, optionMap);
 931                         if (optionMap.size() > 0){
 932                             Set<String> key = optionMap.keySet();
 933                             Iterator<String> i = key.iterator();
 934                             while (i.hasNext()) {
 935                                 String k = (String)i.next();
 936                                 String[] row = {k, optionMap.get(k)};
 937                                 fvOptionTableModel.addRow(row);
 938                             }
 939                         }
 940                     }
 941                 }
 942             });
 943
 944
 945         }
 946         return jTableFvInfo;
 947     }
 948
 949
 950     /**
 951      * This method initializes jButton6
 952      *
 953      * @return javax.swing.JButton
 954      */
 955     private JButton getJButtonDelFvImage() {
 956         if (jButtonDelFvImage == null) {
 957             jButtonDelFvImage = new JButton();
 958             jButtonDelFvImage.setPreferredSize(new java.awt.Dimension(150,20));
 959             jButtonDelFvImage.setText("Delete FV Attributes");
 960             jButtonDelFvImage.addActionListener(new AbstractAction() {
 961                 /**
 962                  *
 963                  */
 964                 private static final long serialVersionUID = 1L;
 965
 966                 public void actionPerformed(ActionEvent arg0) {
 967                     // TODO Auto-generated method stub
 968                     if (jTableFvInfo.getSelectedRow() >= 0 ) {
 969                         String fvNameList = fvImageParaTableModel.getValueAt(jTableFvInfo.getSelectedRow(), 0)+"";
 970                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, jComboBoxFvParaType.getSelectedItem()+"");
 971
 972                         ffc.removeFvImagesFvImage(fvImagePos);
 973                         fvImageParaTableModel.removeRow(jTableFvInfo.getSelectedRow());
 974                         docConsole.setSaved(false);
 975
 976                         fvImageNameTableModel.setRowCount(0);
 977                         fvOptionTableModel.setRowCount(0);
 978                     }
 979                 }
 980
 981             });
 982         }
 983         return jButtonDelFvImage;
 984     }
 985
 986
 987     /**
 988      * This method initializes jPanel6
 989      *
 990      * @return javax.swing.JPanel
 991      */
 992     private JPanel getJPanelFvImagePara() {
 993         if (jPanelFvImagePara == null) {
 994             FlowLayout flowLayout6 = new FlowLayout();
 995             flowLayout6.setAlignment(java.awt.FlowLayout.LEFT);
 996             StarLabel starLabel = new StarLabel();
 997             starLabel.setVisible(false);
 998             jPanelFvImagePara = new JPanel();
 999             jPanelFvImagePara.setLayout(flowLayout6);
1000             jPanelFvImagePara.setPreferredSize(new java.awt.Dimension(450,140));
1001             jPanelFvImagePara.setBorder(javax.swing.BorderFactory.createEtchedBorder(javax.swing.border.EtchedBorder.RAISED));
1002             jPanelFvImagePara.add(new StarLabel(), null);
1003             jPanelFvImagePara.add(jLabelFvImageNames, null);
1004             jPanelFvImagePara.add(jLabelFvParaName, null);
1005             jPanelFvImagePara.add(getJTextFieldFvParaName(), null);
1006             jPanelFvImagePara.add(getJScrollPaneFvImageNames(), null);
1007             jPanelFvImagePara.add(getJPanelBgFvName(), null);
1008             jPanelFvImagePara.add(jLabelFvParaType, null);
1009             jPanelFvImagePara.add(getJComboBoxFvParaType(), null);
1010         }
1011         return jPanelFvImagePara;
1012     }
1013
1014     /**
1015      * This method initializes jPanel7
1016      *
1017      * @return javax.swing.JPanel
1018      */
1019     private JPanel getJPanelFdf() {
1020         if (jPanelFdf == null) {
1021             jPanelFdf = new JPanel();
1022             jPanelFdf.setLayout(new BorderLayout());
1023
1024             jPanelFdf.add(getJPanelFdfN(), java.awt.BorderLayout.NORTH);
1025             jPanelFdf.add(getJPanelFdfS(), java.awt.BorderLayout.SOUTH);
1026             jPanelFdf.add(getJSplitPaneFdfC(), java.awt.BorderLayout.CENTER);
1027             jPanelFdf.addComponentListener(new ComponentAdapter(){
1028                 public void componentShown(ComponentEvent e) {
1029 //                    if (ffc.getFlashDefinitionFile() != null) {
1030 //                        jTextFieldFdf.setText(ffc.getFlashDefinitionFile());
1031 //                        initFvInFdfTable(System.getenv("WORKSPACE") + File.separator + jTextFieldFdf.getText());
1032 //
1033 //                    }
1034                 }
1035                 public void componentHidden(ComponentEvent e) {
1036                     if (jCheckBoxFdf.isSelected()) {
1037                         ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1038                     }
1039                 }
1040             });
1041         }
1042         return jPanelFdf;
1043     }
1044
1045     /**
1046      * This method initializes jCheckBox
1047      *
1048      * @return javax.swing.JCheckBox
1049      */
1050     private JCheckBox getJCheckBoxFdf() {
1051         if (jCheckBoxFdf == null) {
1052             jCheckBoxFdf = new JCheckBox();
1053             jCheckBoxFdf.setText("Flash Definition File");
1054             jCheckBoxFdf.addItemListener(new ItemListener() {
1055
1056                 public void itemStateChanged(ItemEvent arg0) {
1057                     // TODO Auto-generated method stub
1058                     if (jCheckBoxFdf.isSelected()){
1059                         jTextFieldFdf.setEnabled(true);
1060                         jButtonFdfBrowse.setEnabled(true);
1061                     }
1062                     else {
1063
1064                         jTextFieldFdf.setEnabled(false);
1065                         jButtonFdfBrowse.setEnabled(false);
1066                     }
1067                 }
1068             });
1069         }
1070         return jCheckBoxFdf;
1071     }
1072
1073     /**
1074      * This method initializes jTextField3
1075      *
1076      * @return javax.swing.JTextField
1077      */
1078     private JTextField getJTextFieldFdf() {
1079         if (jTextFieldFdf == null) {
1080             jTextFieldFdf = new JTextField();
1081             jTextFieldFdf.setEnabled(false);
1082             jTextFieldFdf.setEditable(false);
1083             jTextFieldFdf.setPreferredSize(new Dimension(300, 20));
1084             jTextFieldFdf.addFocusListener(new java.awt.event.FocusAdapter() {
1085                 public void focusLost(java.awt.event.FocusEvent e) {
1086                     ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1087                 }
1088             });
1089         }
1090         return jTextFieldFdf;
1091     }
1092
1093     /**
1094      * This method initializes jButton5
1095      *
1096      * @return javax.swing.JButton
1097      */
1098     private JButton getJButtonFdfBrowse() {
1099         if (jButtonFdfBrowse == null) {
1100             jButtonFdfBrowse = new JButton();
1101             jButtonFdfBrowse.setEnabled(false);
1102             jButtonFdfBrowse.setText("Browse");
1103             jButtonFdfBrowse.setPreferredSize(new Dimension(78, 20));
1104             jButtonFdfBrowse.addActionListener(new AbstractAction(){
1105                 /**
1106                  *
1107                  */
1108                 private static final long serialVersionUID = 1L;
1109
1110                 public void actionPerformed(ActionEvent e) {
1111                     // TODO Auto-generated method stub
1112                     String wsDir = System.getenv("WORKSPACE");
1113                     JFileChooser chooser = new JFileChooser(wsDir);
1114                     chooser.setMultiSelectionEnabled(false);
1115                     chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
1116                     int retval = chooser.showOpenDialog(frame);
1117                     if (retval == JFileChooser.APPROVE_OPTION) {
1118
1119                         File theFile = chooser.getSelectedFile();
1120                         String filePath = theFile.getPath();
1121                         if (!filePath.startsWith(wsDir)) {
1122                             JOptionPane.showMessageDialog(frame, "You can only select files in current WORKSPACE.");
1123                             return;
1124                         }
1125                         jTextFieldFdf.setText(filePath.substring(wsDir.length() + 1).replace('\\', '/'));
1126                         ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1127                         docConsole.setSaved(false);
1128                         initFvInFdfTable(filePath);
1129                     }
1130                 }
1131
1132             });
1133         }
1134         return jButtonFdfBrowse;
1135     }
1136
1137     private void initFvAttributes () {
1138         if (ffc.getFvImagesFvImageCount("Attributes") == 0 && ffc.getFvImagesFvImageCount("Components") == 0) {
1139             return;
1140         }
1141         String[][] saa = new String[ffc.getFvImagesFvImageCount("Attributes")][2];
1142         ffc.getFvImagesFvImages(saa, "Attributes");
1143
1144         int i = 0;
1145         while (i < saa.length) {
1146             fvImageParaTableModel.addRow(saa[i]);
1147             ++i;
1148         }
1149
1150         saa = new String[ffc.getFvImagesFvImageCount("Components")][2];
1151         ffc.getFvImagesFvImages(saa, "Components");
1152         i = 0;
1153         while (i < saa.length) {
1154             fvImageParaTableModel.addRow(saa[i]);
1155             ++i;
1156         }
1157
1158         saa = new String[ffc.getFvImagesNameValueCount()][2];
1159         ffc.getFvImagesNameValues(saa);
1160         for (int m = 0; m < saa.length; ++m) {
1161             fvPropertyTableModel.addRow(saa[m]);
1162         }
1163     }
1164
1165     private void initFvAdditionalTable() {
1166         Vector<String> vFvNames = new Vector<String>();
1167         ffc.getFvImagesFvImageFvImageNames(vFvNames);
1168         for (int i = 0; i < vFvNames.size(); ++i) {
1169             String fvName = vFvNames.get(i);
1170             if (fvNameExists(fvName)) {
1171                 continue;
1172             }
1173             fvAdditionalTableModel.addRow(getBasicFvInfo(fvName));
1174             addTabForFv(new FvInfoFromFdf(fvName, "", ""));
1175         }
1176     }
1177
1178     private void initFvInFdfTable(String fdfPath){
1179         Vector<FvInfoFromFdf> vFvInfo = new Vector<FvInfoFromFdf>();
1180         getFvInfoFromFdf(fdfPath, vFvInfo);
1181         getFlashInfoFromFdf (fdfPath);
1182         if (!erasePolarity.equals("1") && !erasePolarity.equals("0")) {
1183             JOptionPane.showMessageDialog(frame, "FDF file does NOT contain valid Erase Polarity.");
1184         }
1185         else {
1186             ffc.setTypedFvImageNameValue("Attributes", "EFI_ERASE_POLARITY", erasePolarity);
1187         }
1188
1189         // BugBug: assume all blocks have same size;
1190
1191         String blkSize = defaultBlkSize;
1192         if (vBlockSize.size() > 0) {
1193             blkSize = vBlockSize.get(0);
1194             if (!DataValidation.isInt(blkSize) && !DataValidation.isHexDoubleWordDataType(blkSize)) {
1195                 JOptionPane.showMessageDialog(frame, "FDF file does NOT contain valid FV block size. Default size 0x10000 will be used.");
1196                 blkSize = defaultBlkSize;
1197             }
1198         }
1199         determinedFvBlockSize = blkSize;
1200
1201         getFvInFdfTableModel().setRowCount(0);
1202         for (int j = 0; j < vFvInfo.size(); ++j) {
1203             FvInfoFromFdf fvInfo = vFvInfo.get(j);
1204             String[] row = {fvInfo.getFvName(), fvInfo.getSize(), fvInfo.getEfiFileName()};
1205             // if FV addtional table contains the same FV from fdf file, remove that row.
1206             for (int k = 0; k < jTableFvAdditional.getRowCount(); ++k) {
1207                 if (fvAdditionalTableModel.getValueAt(k, 0).equals(row[0])) {
1208                     fvAdditionalTableModel.removeRow(k);
1209                 }
1210             }
1211             getFvInFdfTableModel().addRow(row);
1212             try {
1213                 int blockSize = Integer.decode(blkSize);
1214                 int fvSize = Integer.decode(row[1]);
1215                 int numBlocks = fvSize/blockSize;
1216                 HashMap<String, String> mOptions = new HashMap<String, String>();
1217                 // if no options for this FV before, generate a new options entry for this FV.
1218                 if (ffc.getFvImagesFvImageWithName(row[0], "Options") == null) {
1219
1220                     mOptions.put("EFI_BLOCK_SIZE", blkSize);
1221                     mOptions.put("EFI_NUM_BLOCKS", numBlocks+"");
1222                     mOptions.put("EFI_FILE_NAME", row[2]);
1223                     ffc.genFvImagesFvImage(new String[]{row[0]}, "Options", mOptions);
1224                     memModified = true;
1225                 }
1226                 else {
1227                     ffc.getFvImagesFvImageOptions(row[0], mOptions);
1228                     if (mOptions.get("EFI_BLOCK_SIZE") == null || !mOptions.get("EFI_BLOCK_SIZE").equalsIgnoreCase(blkSize)) {
1229                         ffc.setTypedNamedFvImageNameValue(row[0], "Options", "EFI_BLOCK_SIZE", blkSize);
1230                         memModified = true;
1231                     }
1232                     if (mOptions.get("EFI_NUM_BLOCKS") == null || Integer.decode(mOptions.get("EFI_NUM_BLOCKS")) != numBlocks) {
1233                         ffc.setTypedNamedFvImageNameValue(row[0], "Options", "EFI_NUM_BLOCKS", numBlocks + "");
1234                         memModified = true;
1235                     }
1236                     if (mOptions.get("EFI_FILE_NAME") == null || !mOptions.get("EFI_FILE_NAME").equals(row[2])) {
1237                         ffc.setTypedNamedFvImageNameValue(row[0], "Options", "EFI_FILE_NAME", row[2]);
1238                         memModified = true;
1239                     }
1240
1241                 }
1242             }
1243             catch (NumberFormatException e){
1244                 JOptionPane.showMessageDialog(frame, e.getMessage());
1245             }
1246         }
1247
1248         for (int k = 0; k < vFvInfo.size(); ++k) {
1249             FvInfoFromFdf fvInfo = vFvInfo.get(k);
1250             addTabForFv(fvInfo);
1251         }
1252
1253     }
1254
1255     private void addTabForFv (FvInfoFromFdf fvInfo) {
1256         String fvName = fvInfo.getFvName();
1257         String outputFile = fvInfo.getEfiFileName();
1258         int index = jTabbedPane.indexOfTab(fvName);
1259         if (index >= startIndexOfDynamicTab) {
1260             return;
1261         }
1262         jTabbedPane.addTab(fvName, null, new ModuleOrderPane(fvName, outputFile), null);
1263     }
1264     /**
1265      * This method initializes jTextField4
1266      *
1267      * @return javax.swing.JTextField
1268      */
1269     private JTextField getJTextFieldFvImageOptName() {
1270         if (jTextFieldFvImageOptName == null) {
1271             jTextFieldFvImageOptName = new JTextField();
1272             jTextFieldFvImageOptName.setEnabled(true);
1273             jTextFieldFvImageOptName.setPreferredSize(new Dimension(100, 20));
1274         }
1275         return jTextFieldFvImageOptName;
1276     }
1277
1278     /**
1279      * This method initializes jTextField5
1280      *
1281      * @return javax.swing.JTextField
1282      */
1283     private JTextField getJTextFieldFvImageOptValue() {
1284         if (jTextFieldFvImageOptValue == null) {
1285             jTextFieldFvImageOptValue = new JTextField();
1286             jTextFieldFvImageOptValue.setEnabled(true);
1287             jTextFieldFvImageOptValue.setPreferredSize(new Dimension(100, 20));
1288         }
1289         return jTextFieldFvImageOptValue;
1290     }
1291
1292     /**
1293      * This method initializes jPanel8
1294      *
1295      * @return javax.swing.JPanel
1296      */
1297     private JPanel getJPanelFvImageOptsButtonGroup() {
1298         if (jPanelFvImageOptsButtonGroup == null) {
1299             jPanelFvImageOptsButtonGroup = new JPanel();
1300             jPanelFvImageOptsButtonGroup.setPreferredSize(new Dimension(80, 55));
1301             jPanelFvImageOptsButtonGroup.add(getJButtonFvImageOptAdd(), null);
1302             jPanelFvImageOptsButtonGroup.add(getJButtonFvImageOptDel(), null);
1303         }
1304         return jPanelFvImageOptsButtonGroup;
1305     }
1306
1307     /**
1308      * This method initializes jButton7
1309      *
1310      * @return javax.swing.JButton
1311      */
1312     private JButton getJButtonFvImageOptAdd() {
1313         if (jButtonFvImageOptAdd == null) {
1314             jButtonFvImageOptAdd = new JButton();
1315             jButtonFvImageOptAdd.setEnabled(true);
1316             jButtonFvImageOptAdd.setText("Add");
1317             jButtonFvImageOptAdd.setPreferredSize(new Dimension(80, 20));
1318             jButtonFvImageOptAdd.addActionListener(new AbstractAction() {
1319                 /**
1320                  *
1321                  */
1322                 private static final long serialVersionUID = 1L;
1323
1324                 public void actionPerformed(ActionEvent e) {
1325                     if (jTextFieldFvImageOptName.getText().length() > 0 && jTextFieldFvImageOptValue.getText().length() > 0){
1326                         int selectedRow = jTableFvInfo.getSelectedRow();
1327                         if (selectedRow < 0) {
1328                             return;
1329                         }
1330
1331                         String fvNameList = jTableFvInfo.getValueAt(selectedRow, 0)+"";
1332                         String type = jTableFvInfo.getValueAt(selectedRow, 1)+"";
1333                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, type);
1334                         String[] row = {jTextFieldFvImageOptName.getText(), jTextFieldFvImageOptValue.getText()};
1335
1336                         if (fvImagePos < 0) {
1337                             return;
1338                         }
1339                         else {
1340                             //append options to FvImage.
1341                             ffc.setFvImagesFvImageNameValue(fvImagePos, row[0], row[1]);
1342                         }
1343                         docConsole.setSaved(false);
1344                         fvOptionTableModel.addRow(row);
1345                         jTableFvImageOpts.changeSelection(jTableFvImageOpts.getRowCount() - 1, 0, false, false);
1346                     }
1347                 }
1348             });
1349         }
1350         return jButtonFvImageOptAdd;
1351     }
1352
1353     /**
1354      * This method initializes jButton8
1355      *
1356      * @return javax.swing.JButton
1357      */
1358     private JButton getJButtonFvImageOptDel() {
1359         if (jButtonFvImageOptDel == null) {
1360             jButtonFvImageOptDel = new JButton();
1361             jButtonFvImageOptDel.setEnabled(true);
1362             jButtonFvImageOptDel.setText("Delete");
1363             jButtonFvImageOptDel.setPreferredSize(new Dimension(80, 20));
1364             jButtonFvImageOptDel.addActionListener(new AbstractAction() {
1365                 /**
1366                  *
1367                  */
1368                 private static final long serialVersionUID = 1L;
1369
1370                 public void actionPerformed(ActionEvent e) {
1371                     if (jTableFvImageOpts.getSelectedRow() >= 0){
1372                         int selectedRow = jTableFvInfo.getSelectedRow();
1373                         if (selectedRow < 0) {
1374                             return;
1375                         }
1376
1377                         String fvNameList = jTableFvInfo.getValueAt(selectedRow, 0)+"";
1378                         String type = jTableFvInfo.getValueAt(selectedRow, 1)+"";
1379                         int fvImagePos = ffc.getFvImagePosInFvImages(fvNameList, type);
1380                         if (fvImagePos < 0) {
1381                             return;
1382                         }
1383
1384                         String optName = fvOptionTableModel.getValueAt(jTableFvImageOpts.getSelectedRow(), 0)+"";
1385                         ffc.removeFvImageNameValue(fvImagePos, optName);
1386                         docConsole.setSaved(false);
1387                         fvOptionTableModel.removeRow(jTableFvImageOpts.getSelectedRow());
1388                     }
1389                 }
1390             });
1391         }
1392         return jButtonFvImageOptDel;
1393     }
1394
1395     /**
1396      * This method initializes jScrollPane
1397      *
1398      * @return javax.swing.JScrollPane
1399      */
1400     private JScrollPane getJScrollPane() {
1401         if (jScrollPane == null) {
1402             jScrollPane = new JScrollPane();
1403             jScrollPane.setPreferredSize(new java.awt.Dimension(350,100));
1404             jScrollPane.setViewportView(getJTableFvImageOpts());
1405         }
1406         return jScrollPane;
1407     }
1408
1409     /**
1410      * This method initializes jTable3
1411      *
1412      * @return javax.swing.JTable
1413      */
1414     private JTable getJTableFvImageOpts() {
1415         if (jTableFvImageOpts == null) {
1416             fvOptionTableModel = new NonEditableTableModel();
1417             fvOptionTableModel.addColumn("Name");
1418             fvOptionTableModel.addColumn("Value");
1419             jTableFvImageOpts = new JTable(fvOptionTableModel);
1420
1421             jTableFvImageOpts.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1422             jTableFvImageOpts.setRowHeight(20);
1423
1424         }
1425         return jTableFvImageOpts;
1426     }
1427
1428     /**
1429      * This method initializes jButton9
1430      *
1431      * @return javax.swing.JButton
1432      */
1433     private JButton getJButtonUpdateFvImage() {
1434         if (jButtonUpdateFvImage == null) {
1435             jButtonUpdateFvImage = new JButton();
1436             jButtonUpdateFvImage.setPreferredSize(new java.awt.Dimension(150,20));
1437             jButtonUpdateFvImage.setActionCommand("Update");
1438             jButtonUpdateFvImage.setText("Update FV Attributes");
1439             jButtonUpdateFvImage.setVisible(false);
1440             jButtonUpdateFvImage.addActionListener(new java.awt.event.ActionListener() {
1441                 public void actionPerformed(java.awt.event.ActionEvent e) {
1442                     int row = jTableFvInfo.getSelectedRow();
1443                     if (jTableFvInfo.isEditing()) {
1444                         jTableFvInfo.getCellEditor().stopCellEditing();
1445                     }
1446                     if (jTableFvImageOpts.isEditing()) {
1447                         jTableFvImageOpts.getCellEditor().stopCellEditing();
1448                     }
1449
1450                         //ToDo Check data validity before update
1451                         String name = fvImageParaTableModel.getValueAt(row, 0) + "";
1452                         String type = fvImageParaTableModel.getValueAt(row, 1) + "";
1453
1454                         LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
1455                         getOptionNameValue(lhm);
1456
1457                         docConsole.setSaved(false);
1458                         ffc.updateFvImagesFvImage(row, name.split(" "), type, lhm);
1459
1460                 }
1461             });
1462         }
1463         return jButtonUpdateFvImage;
1464     }
1465
1466     /**
1467      * This method initializes jPanelFdfN
1468      *
1469      * @return javax.swing.JPanel
1470      */
1471     private JPanel getJPanelFdfN() {
1472         if (jPanelFdfN == null) {
1473             jPanelFdfN = new JPanel();
1474             jPanelFdfN.add(getJCheckBoxFdf(), null);
1475             jPanelFdfN.add(getJTextFieldFdf(), null);
1476             jPanelFdfN.add(getJButtonFdfBrowse(), null);
1477         }
1478         return jPanelFdfN;
1479     }
1480
1481     /**
1482      * This method initializes jPanelFdfS
1483      *
1484      * @return javax.swing.JPanel
1485      */
1486     private JPanel getJPanelFdfS() {
1487         if (jPanelFdfS == null) {
1488             FlowLayout flowLayout4 = new FlowLayout();
1489             flowLayout4.setAlignment(java.awt.FlowLayout.RIGHT);
1490             jPanelFdfS = new JPanel();
1491             jPanelFdfS.setLayout(flowLayout4);
1492             jPanelFdfS.add(getJButtonAddFv(), null);
1493             jPanelFdfS.add(getJButtonDelFv(), null);
1494             jPanelFdfS.add(getJButtonAddFvOptions(), null);
1495         }
1496         return jPanelFdfS;
1497     }
1498
1499     /**
1500      * This method initializes jSplitPaneFdfC
1501      *
1502      * @return javax.swing.JSplitPane
1503      */
1504     private JSplitPane getJSplitPaneFdfC() {
1505         if (jSplitPaneFdfC == null) {
1506             jSplitPaneFdfC = new JSplitPane();
1507             jSplitPaneFdfC.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1508             jSplitPaneFdfC.setDividerSize(5);
1509             jSplitPaneFdfC.setTopComponent(getJPanelFdfCTop());
1510             jSplitPaneFdfC.setBottomComponent(getJPanelFdfCBottom());
1511             jSplitPaneFdfC.setDividerLocation(280);
1512         }
1513         return jSplitPaneFdfC;
1514     }
1515
1516     /**
1517      * This method initializes jPanelFdfCTop
1518      *
1519      * @return javax.swing.JPanel
1520      */
1521     private JPanel getJPanelFdfCTop() {
1522         if (jPanelFdfCTop == null) {
1523             jPanelFdfCTop = new JPanel();
1524             jPanelFdfCTop.setLayout(new BorderLayout());
1525             jPanelFdfCTop.add(getJPanelFdfCTopN(), java.awt.BorderLayout.NORTH);
1526             jPanelFdfCTop.add(getJPanelFdfCTopS(), java.awt.BorderLayout.SOUTH);
1527             jPanelFdfCTop.add(getJPanelFdfCTopC(), java.awt.BorderLayout.CENTER);
1528         }
1529         return jPanelFdfCTop;
1530     }
1531
1532     /**
1533      * This method initializes jPanelFdfCBottom
1534      *
1535      * @return javax.swing.JPanel
1536      */
1537     private JPanel getJPanelFdfCBottom() {
1538         if (jPanelFdfCBottom == null) {
1539             jPanelFdfCBottom = new JPanel();
1540             jPanelFdfCBottom.setLayout(new BorderLayout());
1541             jPanelFdfCBottom.add(getJPanelFdfCBottomN(), java.awt.BorderLayout.NORTH);
1542             jPanelFdfCBottom.add(getJPanelFdfCBottomC(), java.awt.BorderLayout.CENTER);
1543         }
1544         return jPanelFdfCBottom;
1545     }
1546
1547     /**
1548      * This method initializes jPanelFdfCTopN
1549      *
1550      * @return javax.swing.JPanel
1551      */
1552     private JPanel getJPanelFdfCTopN() {
1553         if (jPanelFdfCTopN == null) {
1554             jLabelFvInFdf = new JLabel();
1555             jLabelFvInFdf.setText("FVs in Flash Definition File");
1556             jPanelFdfCTopN = new JPanel();
1557             jPanelFdfCTopN.add(jLabelFvInFdf, null);
1558         }
1559         return jPanelFdfCTopN;
1560     }
1561
1562     /**
1563      * This method initializes jPanelFdfCTopS
1564      *
1565      * @return javax.swing.JPanel
1566      */
1567     private JPanel getJPanelFdfCTopS() {
1568         if (jPanelFdfCTopS == null) {
1569             FlowLayout flowLayout1 = new FlowLayout();
1570             flowLayout1.setAlignment(java.awt.FlowLayout.RIGHT);
1571             jPanelFdfCTopS = new JPanel();
1572             jPanelFdfCTopS.setLayout(flowLayout1);
1573             jPanelFdfCTopS.add(getJButtonFvInFdfOptions(), null);
1574         }
1575         return jPanelFdfCTopS;
1576     }
1577
1578     /**
1579      * This method initializes jPanelFdfCTopC
1580      *
1581      * @return javax.swing.JPanel
1582      */
1583     private JPanel getJPanelFdfCTopC() {
1584         if (jPanelFdfCTopC == null) {
1585             jPanelFdfCTopC = new JPanel();
1586             jPanelFdfCTopC.add(getJScrollPaneFvInFdf(), null);
1587         }
1588         return jPanelFdfCTopC;
1589     }
1590
1591     /**
1592      * This method initializes jPanelFdfCBottomN
1593      *
1594      * @return javax.swing.JPanel
1595      */
1596     private JPanel getJPanelFdfCBottomN() {
1597         if (jPanelFdfCBottomN == null) {
1598             jLabelFvAdditional = new JLabel();
1599             jLabelFvAdditional.setText("Additional FVs");
1600             jPanelFdfCBottomN = new JPanel();
1601             jPanelFdfCBottomN.add(jLabelFvAdditional, null);
1602         }
1603         return jPanelFdfCBottomN;
1604     }
1605
1606     /**
1607      * This method initializes jPanelFdfCBottomC
1608      *
1609      * @return javax.swing.JPanel
1610      */
1611     private JPanel getJPanelFdfCBottomC() {
1612         if (jPanelFdfCBottomC == null) {
1613             jPanelFdfCBottomC = new JPanel();
1614             jPanelFdfCBottomC.add(getJScrollPaneFvAdditional(), null);
1615         }
1616         return jPanelFdfCBottomC;
1617     }
1618
1619     /**
1620      * This method initializes jScrollPaneFvInFdf
1621      *
1622      * @return javax.swing.JScrollPane
1623      */
1624     private JScrollPane getJScrollPaneFvInFdf() {
1625         if (jScrollPaneFvInFdf == null) {
1626             jScrollPaneFvInFdf = new JScrollPane();
1627             jScrollPaneFvInFdf.setPreferredSize(new java.awt.Dimension(653,200));
1628             jScrollPaneFvInFdf.setViewportView(getJTableFvInFdf());
1629         }
1630         return jScrollPaneFvInFdf;
1631     }
1632
1633     /**
1634      * This method initializes jTableFvInFdf
1635      *
1636      * @return javax.swing.JTable
1637      */
1638     private JTable getJTableFvInFdf() {
1639         if (jTableFvInFdf == null) {
1640             jTableFvInFdf = new JTable();
1641             jTableFvInFdf.setRowHeight(20);
1642             jTableFvInFdf.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
1643             jTableFvInFdf.setModel(getFvInFdfTableModel());
1644         }
1645         return jTableFvInFdf;
1646     }
1647
1648     /**
1649      * This method initializes fvInFdfTableModel
1650      *
1651      * @return org.tianocore.frameworkwizard.platform.ui.NonEditableTableModel
1652      */
1653     private NonEditableTableModel getFvInFdfTableModel() {
1654         if (fvInFdfTableModel == null) {
1655             fvInFdfTableModel = new NonEditableTableModel();
1656             fvInFdfTableModel.addColumn("FV Name");
1657             fvInFdfTableModel.addColumn("Size");
1658             fvInFdfTableModel.addColumn("Corresponding File Name");
1659         }
1660         return fvInFdfTableModel;
1661     }
1662
1663     /**
1664      * This method initializes jButtonFvInFdfOptions
1665      *
1666      * @return javax.swing.JButton
1667      */
1668     private JButton getJButtonFvInFdfOptions() {
1669         if (jButtonFvInFdfOptions == null) {
1670             jButtonFvInFdfOptions = new JButton();
1671             jButtonFvInFdfOptions.setPreferredSize(new java.awt.Dimension(80,20));
1672             jButtonFvInFdfOptions.setEnabled(true);
1673             jButtonFvInFdfOptions.setText("Options");
1674             jButtonFvInFdfOptions.addActionListener(new java.awt.event.ActionListener() {
1675                 public void actionPerformed(java.awt.event.ActionEvent e) {
1676                     int selectedRow = jTableFvInFdf.getSelectedRow();
1677                     if (selectedRow < 0) {
1678                         return;
1679                     }
1680                     String fvName = jTableFvInFdf.getValueAt(selectedRow, 0)+"";
1681                     if (fvName.length() == 0) {
1682                         return;
1683                     }
1684                     DefaultTableModel dtm = getFvInFdfOptTableModel();
1685                     new FpdFvOptions(fvName, dtm, ffc, docConsole);
1686                 }
1687             });
1688         }
1689         return jButtonFvInFdfOptions;
1690     }
1691
1692     private DefaultTableModel getFvInFdfOptTableModel() {
1693         if (fvInFdfOptTableModel == null) {
1694             fvInFdfOptTableModel = new FvOptsTableModel();
1695             fvInFdfOptTableModel.addColumn("Name");
1696             fvInFdfOptTableModel.addColumn("Value");
1697             Vector<Object> v = new Vector<Object>();
1698             v.add("EFI_BLOCK_SIZE");
1699             v.add("EFI_NUM_BLOCKS");
1700             v.add("EFI_FILE_NAME");
1701             fvInFdfOptTableModel.setVKeyWords(v);
1702             fvInFdfOptTableModel.setVNonEditableName(v);
1703         }
1704         return fvInFdfOptTableModel;
1705     }
1706
1707     private DefaultTableModel getFvAdditionalOptTableModel() {
1708         if (fvAdditionalOptTableModel == null) {
1709             fvAdditionalOptTableModel = new FvOptsTableModel();
1710             fvAdditionalOptTableModel.addColumn("Name");
1711             fvAdditionalOptTableModel.addColumn("Value");
1712             Vector<Object> v = new Vector<Object>();
1713             v.add("EFI_BLOCK_SIZE");
1714             v.add("EFI_NUM_BLOCKS");
1715             v.add("EFI_FILE_NAME");
1716             fvAdditionalOptTableModel.setVNonEditableName(v);
1717         }
1718         return fvAdditionalOptTableModel;
1719     }
1720
1721     /**
1722      * This method initializes jScrollPaneFvAdditional
1723      *
1724      * @return javax.swing.JScrollPane
1725      */
1726     private JScrollPane getJScrollPaneFvAdditional() {
1727         if (jScrollPaneFvAdditional == null) {
1728             jScrollPaneFvAdditional = new JScrollPane();
1729             jScrollPaneFvAdditional.setPreferredSize(new java.awt.Dimension(653,200));
1730             jScrollPaneFvAdditional.setViewportView(getJTableFvAdditional());
1731         }
1732         return jScrollPaneFvAdditional;
1733     }
1734
1735     /**
1736      * This method initializes jTableFvAdditional
1737      *
1738      * @return javax.swing.JTable
1739      */
1740     private JTable getJTableFvAdditional() {
1741         if (jTableFvAdditional == null) {
1742             jTableFvAdditional = new JTable();
1743             jTableFvAdditional.setRowHeight(20);
1744             jTableFvAdditional.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
1745             jTableFvAdditional.setModel(getFvAdditionalTableModel());
1746
1747             jTableFvAdditional.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
1748                 public void valueChanged(ListSelectionEvent e) {
1749                     if (e.getValueIsAdjusting()) {
1750                         return;
1751                     }
1752                     ListSelectionModel lsm = (ListSelectionModel) e.getSource();
1753                     if (lsm.isSelectionEmpty()) {
1754                         return;
1755                     } else {
1756                         selectedRowInFvAdditionalTable = lsm.getMinSelectionIndex();
1757                         oldFvName = jTableFvAdditional.getValueAt(selectedRowInFvAdditionalTable, 0)+"";
1758                     }
1759                 }
1760             });
1761
1762             jTableFvAdditional.getModel().addTableModelListener(new TableModelListener() {
1763                 public void tableChanged(TableModelEvent arg0) {
1764                     // TODO Auto-generated method stub
1765                     int row = arg0.getFirstRow();
1766                     int col = arg0.getColumn();
1767                     TableModel m = (TableModel) arg0.getSource();
1768
1769                     if (arg0.getType() == TableModelEvent.UPDATE) {
1770                         if (col == 0) {
1771                             String newFvName = m.getValueAt(row, 0) + "";
1772                             if (newFvName.equals(oldFvName)) {
1773                                 return;
1774                             }
1775                             if (fvNameExists(newFvName)) {
1776                                 JOptionPane.showMessageDialog(frame, "This FV already exists. Please choose another FV name.");
1777                                 m.setValueAt(oldFvName, row, 0);
1778                                 return;
1779                             }
1780
1781                             tabIndexForFv = jTabbedPane.indexOfTab(oldFvName);
1782                             if (tabIndexForFv >= startIndexOfDynamicTab) {
1783                                 jTabbedPane.setTitleAt(tabIndexForFv, newFvName);
1784                                 // change FvName in UserExtensions
1785                                 ffc.updateBuildOptionsUserExtensions(oldFvName, newFvName);
1786                                 // change FvBinding in ModuleSA
1787                                 ffc.appendFvBindingFor(oldFvName, newFvName);
1788                                 ffc.removeFvBindingAll(oldFvName);
1789                                 // change FvImageNames in Flash
1790                                 ffc.updateFvImageNameAll(oldFvName, newFvName);
1791
1792                             } else {
1793                                 jTabbedPane.addTab(newFvName, new ModuleOrderPane(newFvName, ""));
1794                                 // Add FvImageNames in Flash
1795                                 String[] fvNames = {newFvName};
1796                                 ffc.addFvImageFvImageNames(fvNames);
1797                             }
1798                             docConsole.setSaved(false);
1799                             oldFvName = newFvName;
1800                         }
1801
1802                         if (col == 1 && !sizeFromOptionDlg) {
1803                             String fvSize = m.getValueAt(row, col) + "";
1804                             if (!DataValidation.isInt(fvSize) && !DataValidation.isHexDoubleWordDataType(fvSize)) {
1805                                 JOptionPane.showMessageDialog(frame, "FV size should be Integer or Hex format.");
1806                                 return;
1807                             }
1808                             HashMap<String, String> mFvOpts = new HashMap<String, String>();
1809                             ffc.getFvImagesFvImageOptions(oldFvName, mFvOpts);
1810                             String blkSize = mFvOpts.get("EFI_BLOCK_SIZE");
1811                             if (blkSize == null) {
1812                                 if (determinedFvBlockSize != null) {
1813                                     blkSize = determinedFvBlockSize;
1814                                 }
1815                                 else {
1816                                     blkSize = defaultBlkSize;
1817                                 }
1818                                 ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_BLOCK_SIZE", blkSize);
1819                                 int fs = Integer.decode(fvSize);
1820                                 int bs = Integer.decode(blkSize);
1821                                 ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_NUM_BLOCKS", (fs/bs)+"");
1822                                 docConsole.setSaved(false);
1823                             }
1824                             else {
1825                                 if (!DataValidation.isInt(blkSize) && !DataValidation.isHexDoubleWordDataType(blkSize)) {
1826                                     int retVal = JOptionPane.showConfirmDialog(frame, "Confirm", "FPD file contains error block size format. Would you like to replace it with a default value?", JOptionPane.YES_NO_OPTION);
1827                                     if (retVal == JOptionPane.YES_OPTION) {
1828                                         ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_BLOCK_SIZE", defaultBlkSize);
1829                                         int fs = Integer.decode(fvSize);
1830                                         int bs = Integer.decode(defaultBlkSize);
1831                                         ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_NUM_BLOCKS", (fs/bs)+"");
1832                                         docConsole.setSaved(false);
1833                                         return;
1834                                     }
1835                                     else {
1836                                         return;
1837                                     }
1838
1839                                 }
1840                                 int fs = Integer.decode(fvSize);
1841                                 int bs = Integer.decode(blkSize);
1842                                 ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_NUM_BLOCKS", (fs/bs)+"");
1843                                 docConsole.setSaved(false);
1844                             }
1845                         }
1846
1847                         if (col == 2 && !fileFromOptionDlg) {
1848                             ffc.setTypedNamedFvImageNameValue(oldFvName, "Options", "EFI_FILE_NAME", m.getValueAt(row, col)+"");
1849                             docConsole.setSaved(false);
1850                         }
1851
1852                     }
1853                 }
1854             });
1855         }
1856         return jTableFvAdditional;
1857     }
1858
1859     private boolean fvNameExistsInFvInFdfTable (String fvName) {
1860         for (int i = 0; i < jTableFvInFdf.getRowCount(); ++i) {
1861             if (fvInFdfTableModel.getValueAt(i, 0).equals(fvName)) {
1862                 return true;
1863             }
1864         }
1865         return false;
1866     }
1867
1868     private boolean fvNameExists (String fvName) {
1869         if (fvNameExistsInFvInFdfTable(fvName)) {
1870             return true;
1871         }
1872
1873         for (int j = 0; j < jTableFvAdditional.getRowCount(); ++j) {
1874             if (fvAdditionalTableModel.getValueAt(j, 0).equals(fvName) && j != selectedRowInFvAdditionalTable) {
1875                 return true;
1876             }
1877         }
1878         return false;
1879     }
1880
1881     /**
1882      * This method initializes fvAdditionalTableModel
1883      *
1884      * @return javax.swing.table.DefaultTableModel
1885      */
1886     private DefaultTableModel getFvAdditionalTableModel() {
1887         if (fvAdditionalTableModel == null) {
1888             fvAdditionalTableModel = new DefaultTableModel();
1889             fvAdditionalTableModel.addColumn("FV Name");
1890             fvAdditionalTableModel.addColumn("Size");
1891             fvAdditionalTableModel.addColumn("Corresponding File Name");
1892         }
1893         return fvAdditionalTableModel;
1894     }
1895
1896     /**
1897      * This method initializes jButtonAddFv
1898      *
1899      * @return javax.swing.JButton
1900      */
1901     private JButton getJButtonAddFv() {
1902         if (jButtonAddFv == null) {
1903             jButtonAddFv = new JButton();
1904             jButtonAddFv.setPreferredSize(new java.awt.Dimension(80,20));
1905             jButtonAddFv.setEnabled(true);
1906             jButtonAddFv.setText("New");
1907             jButtonAddFv.addActionListener(new java.awt.event.ActionListener() {
1908                 public void actionPerformed(java.awt.event.ActionEvent e) {
1909                     if (jTableFvAdditional.isEditing()) {
1910                         jTableFvAdditional.getCellEditor().stopCellEditing();
1911                     }
1912                     String[] row = {"", "", ""};
1913                     fvAdditionalTableModel.addRow(row);
1914                 }
1915             });
1916         }
1917         return jButtonAddFv;
1918     }
1919
1920     /**
1921      * This method initializes jButtonDelFv
1922      *
1923      * @return javax.swing.JButton
1924      */
1925     private JButton getJButtonDelFv() {
1926         if (jButtonDelFv == null) {
1927             jButtonDelFv = new JButton();
1928             jButtonDelFv.setPreferredSize(new java.awt.Dimension(80,20));
1929             jButtonDelFv.setEnabled(true);
1930             jButtonDelFv.setText("Delete");
1931             jButtonDelFv.addActionListener(new java.awt.event.ActionListener() {
1932                 public void actionPerformed(java.awt.event.ActionEvent e) {
1933                     //delete row in FvAdditional table.
1934                     int selectedRow = jTableFvAdditional.getSelectedRow();
1935                     if (selectedRow < 0) {
1936                         return;
1937                     }
1938                     String fvName = fvAdditionalTableModel.getValueAt(selectedRow, 0) + "";
1939                     fvAdditionalTableModel.removeRow(selectedRow);
1940                     //
1941                     //delete tab with selected FV name.
1942                     //
1943                     jTabbedPane.removeTabAt(jTabbedPane.indexOfTab(fvName));
1944                     //delete FV Name from FvImages element.
1945                     ffc.updateFvImageNameAll(fvName, null);
1946                     //delete FvBinding from ModuleSA.
1947                     ffc.removeFvBindingAll(fvName);
1948                     docConsole.setSaved(false);
1949                 }
1950             });
1951         }
1952         return jButtonDelFv;
1953     }
1954
1955     /**
1956      * This method initializes jButtonAddFvOptions
1957      *
1958      * @return javax.swing.JButton
1959      */
1960     private JButton getJButtonAddFvOptions() {
1961         if (jButtonAddFvOptions == null) {
1962             jButtonAddFvOptions = new JButton();
1963             jButtonAddFvOptions.setPreferredSize(new java.awt.Dimension(80,20));
1964             jButtonAddFvOptions.setEnabled(true);
1965             jButtonAddFvOptions.setText("Options");
1966             jButtonAddFvOptions.addActionListener(new java.awt.event.ActionListener() {
1967                 public void actionPerformed(java.awt.event.ActionEvent e) {
1968                     int selectedRow = jTableFvAdditional.getSelectedRow();
1969                     if (selectedRow < 0) {
1970                         return;
1971                     }
1972                     String fvName = jTableFvAdditional.getValueAt(selectedRow, 0)+"";
1973                     String oldFvSize = jTableFvAdditional.getValueAt(selectedRow, 1)+"";
1974                     String oldFileName = jTableFvAdditional.getValueAt(selectedRow, 2)+"";
1975                     if (fvName.length() == 0) {
1976                         return;
1977                     }
1978                     DefaultTableModel dtm = getFvAdditionalOptTableModel();
1979                     new FpdFvOptions(fvName, dtm, ffc, docConsole);
1980
1981                     String[] updatedFvInfo = getBasicFvInfo (fvName);
1982                     if (!oldFvSize.equalsIgnoreCase(updatedFvInfo[1])) {
1983                         sizeFromOptionDlg = true;
1984                         jTableFvAdditional.setValueAt(updatedFvInfo[1], selectedRow, 1);
1985                         sizeFromOptionDlg = false;
1986                     }
1987                     if (!oldFileName.equals(updatedFvInfo[2])) {
1988                         fileFromOptionDlg = true;
1989                         jTableFvAdditional.setValueAt(updatedFvInfo[2], selectedRow, 2);
1990                         fileFromOptionDlg = false;
1991                     }
1992                 }
1993             });
1994         }
1995         return jButtonAddFvOptions;
1996     }
1997
1998     private String[] getBasicFvInfo (String fvName) {
1999         HashMap<String, String> mFvOpts = new HashMap<String, String>();
2000         ffc.getFvImagesFvImageOptions(fvName, mFvOpts);
2001         String bSize = "";
2002         String numBlks = "";
2003         String fvSize = "";
2004         String fvFile = "";
2005         if (mFvOpts.get("EFI_FILE_NAME") != null) {
2006             fvFile = mFvOpts.get("EFI_FILE_NAME");
2007         }
2008         if (mFvOpts.get("EFI_BLOCK_SIZE") != null && mFvOpts.get("EFI_NUM_BLOCKS") != null) {
2009             bSize = mFvOpts.get("EFI_BLOCK_SIZE");
2010             numBlks = mFvOpts.get("EFI_NUM_BLOCKS");
2011             boolean blockSizeWellFormat = true;
2012             boolean numOfBlockWellFormat = true;
2013             if (!DataValidation.isHexDoubleWordDataType(bSize) && !DataValidation.isInt(bSize)) {
2014                blockSizeWellFormat = false;
2015                JOptionPane.showMessageDialog(frame, fvName + " block size bad format.");
2016             }
2017             if (!DataValidation.isHexDoubleWordDataType(numBlks) && !DataValidation.isInt(numBlks)) {
2018                numOfBlockWellFormat = false;
2019                JOptionPane.showMessageDialog(frame, fvName + " number of blocks bad format.");
2020             }
2021             if (blockSizeWellFormat && numOfBlockWellFormat) {
2022                 int size = Integer.decode(bSize);
2023                 int num = Integer.decode(numBlks);
2024                 fvSize = "0x" + Integer.toHexString(size*num);
2025             }
2026         }
2027
2028         return new String[]{fvName, fvSize, fvFile};
2029
2030     }
2031
2032     /**
2033      * This method initializes jPanelBgFvName
2034      *
2035      * @return javax.swing.JPanel
2036      */
2037     private JPanel getJPanelBgFvName() {
2038         if (jPanelBgFvName == null) {
2039             jPanelBgFvName = new JPanel();
2040             jPanelBgFvName.setPreferredSize(new java.awt.Dimension(80,55));
2041             jPanelBgFvName.add(getJButtonFvNameAdd(), null);
2042             jPanelBgFvName.add(getJButtonFvNameDel(), null);
2043         }
2044         return jPanelBgFvName;
2045     }
2046
2047     /**
2048      * This method initializes jPanelBgFvImage
2049      *
2050      * @return javax.swing.JPanel
2051      */
2052     private JPanel getJPanelBgFvImage() {
2053         if (jPanelBgFvImage == null) {
2054             jPanelBgFvImage = new JPanel();
2055             jPanelBgFvImage.setPreferredSize(new java.awt.Dimension(150,100));
2056             jPanelBgFvImage.add(getJButtonAddFvImage(), null);
2057             jPanelBgFvImage.add(getJButtonDelFvImage(), null);
2058             jPanelBgFvImage.add(getJButtonUpdateFvImage(), null);
2059         }
2060         return jPanelBgFvImage;
2061     }
2062
2063     /**
2064      * This method initializes jPanelW
2065      *
2066      * @return javax.swing.JPanel
2067      */
2068     private JPanel getJPanelW() {
2069         if (jPanelW == null) {
2070             jPanelW = new JPanel();
2071             jPanelW.add(getJPanelBgFvImage(), null);
2072         }
2073         return jPanelW;
2074     }
2075
2076     /**
2077      * @param args
2078      */
2079     public static void main(String[] args) {
2080         // TODO Auto-generated method stub
2081         new FpdFlash().setVisible(true);
2082     }
2083
2084     /**
2085      * This method initializes this
2086      *
2087      * @return void
2088      */
2089     private void initialize() {
2090         this.setSize(660, 650);
2091         this.setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
2092         this.setContentPane(getJContentPane());
2093         this.setTitle("FPD Flash Definitions");
2094         this.addInternalFrameListener(new InternalFrameAdapter(){
2095             public void internalFrameDeactivated(InternalFrameEvent e){
2096                 if (jTableFvProp.isEditing()) {
2097                     jTableFvProp.getCellEditor().stopCellEditing();
2098                 }
2099                 if (jTableFvImageNames.isEditing()) {
2100                     jTableFvImageNames.getCellEditor().stopCellEditing();
2101                 }
2102                 if (jTableFvInfo.isEditing()) {
2103                     jTableFvInfo.getCellEditor().stopCellEditing();
2104                 }
2105                 if (jTableFvAdditional.isEditing()) {
2106                     jTableFvAdditional.getCellEditor().stopCellEditing();
2107                 }
2108             }
2109         });
2110     }
2111
2112     private void init(FpdFileContents ffc) {
2113         initFvAttributes();
2114
2115         jTextFieldFdf.setText("");
2116         String fdfFile = ffc.getFlashDefinitionFile();
2117         if (fdfFile != null && fdfFile.length() > 0) {
2118             jTextFieldFdf.setText(fdfFile);
2119             String fdfPath = System.getenv("WORKSPACE") + File.separator + fdfFile;
2120             initFvInFdfTable(fdfPath);
2121         }
2122
2123         initFvAdditionalTable();
2124     }
2125
2126     private void getOptionNameValue(Map<String, String> m){
2127         for (int i = 0; i < jTableFvImageOpts.getRowCount(); ++i) {
2128             m.put(fvOptionTableModel.getValueAt(i, 0)+"", fvOptionTableModel.getValueAt(i, 1)+"");
2129         }
2130     }
2131     /**
2132      * This method initializes jContentPane
2133      *
2134      * @return javax.swing.JPanel
2135      */
2136     private JPanel getJContentPane() {
2137         if (jContentPane == null) {
2138             jContentPane = new JPanel();
2139             jContentPane.setLayout(new BorderLayout());
2140             jContentPane.add(getJPanelContentEast(), java.awt.BorderLayout.EAST);
2141             jContentPane.add(getJPanelContentSouth(), java.awt.BorderLayout.SOUTH);
2142             jContentPane.add(getJPanelContentWest(), java.awt.BorderLayout.WEST);
2143             jContentPane.add(getJPanelContentNorth(), java.awt.BorderLayout.NORTH);
2144             jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
2145         }
2146         return jContentPane;
2147     }
2148
2149     private void getFlashInfoFromFdf (String fdfPath) {
2150         File fdf = new File(fdfPath);
2151         if (!fdf.exists()) {
2152             return;
2153         }
2154         int lines = 0;
2155
2156         try {
2157             FileReader reader = new FileReader(fdf);
2158             BufferedReader in = new BufferedReader(reader);
2159             String str;
2160
2161             while ((str = in.readLine()) != null) {
2162                 ++lines;
2163                 str = str.trim();
2164                 //
2165                 // skip empty line, comment (start with //)
2166                 //
2167                 if (str.length() == 0 || str.startsWith("//")) {
2168                     continue;
2169                 }
2170                 //
2171                 // ErasePolarity
2172                 //
2173                 if (str.startsWith("ErasePolarity")) {
2174                     erasePolarity = str.substring(str.indexOf("=") + 1, str.lastIndexOf(",")).trim();
2175                 }
2176                 //
2177                 // dig into Block section.
2178                 //
2179                 if (str.startsWith("Block") && str.endsWith("}")) {
2180                     String[] blockSec = str.split(",");
2181                     String nv = blockSec[1].trim();
2182                     String[] sizeSec = nv.split("=");
2183                     vBlockSize.add(sizeSec[1].trim());
2184                 }
2185
2186             }
2187
2188             reader.close();
2189             in.close();
2190         }
2191         catch (Exception e) {
2192
2193         }
2194     }
2195
2196     private void getFvInfoFromFdf(String fdfPath, Vector<FvInfoFromFdf> vFvInfo) {
2197         File fdf = new File(fdfPath);
2198         if (!fdf.exists()) {
2199             return;
2200         }
2201         int lines = 0;
2202
2203         try {
2204             FileReader reader = new FileReader(fdf);
2205             BufferedReader in = new BufferedReader(reader);
2206             String str;
2207
2208             while ((str = in.readLine()) != null) {
2209                 ++lines;
2210                 str = str.trim();
2211                 //
2212                 // skip empty line, comment (start with //)
2213                 //
2214                 if (str.length() == 0 || str.startsWith("//")) {
2215                     continue;
2216                 }
2217                 //
2218                 // dig into Region {} section, create FvInfoFromFdf object for it.
2219                 //
2220                 if (str.startsWith("Region") && str.endsWith("{")) {
2221                     FvInfoFromFdf fvInfo = new FvInfoFromFdf();
2222                     boolean nameFound = false;
2223                     boolean sizeFound = false;
2224                     while ((str = in.readLine()) != null) {
2225                         ++lines;
2226                         str = str.trim();
2227                         //
2228                         // skip empty line, comment (start with //)
2229                         //
2230                         if (str.length() == 0 || str.startsWith("//")) {
2231                             continue;
2232                         }
2233
2234                         if (str.startsWith("Name")) {
2235                             int firstQuote = str.indexOf("\"");
2236                             int lastQuote = str.lastIndexOf("\"");
2237                             fvInfo.setFvName(str.substring(firstQuote + 1, lastQuote));
2238                             nameFound = true;
2239                         }
2240
2241                         if (str.startsWith("Size")) {
2242                             int equalIndex = str.indexOf("=");
2243                             int commaIndex = str.indexOf(",");
2244                             fvInfo.setSize(str.substring(equalIndex + 1, commaIndex).trim());
2245                             sizeFound = true;
2246                         }
2247
2248                         if (nameFound && sizeFound) {
2249                             break;
2250                         }
2251                     }
2252
2253                     vFvInfo.add(fvInfo);
2254                 }
2255                 //
2256                 // dig into File {} section, supply file name information to existing FvInfoFromFdf object.
2257                 //
2258                 if (str.startsWith("File")) {
2259                     boolean fileNameFound = false;
2260                     boolean fvFound = false;
2261                     String fileName = "";
2262                     String fvName = "";
2263                     while ((str = in.readLine()) != null) {
2264                         ++lines;
2265                         str = str.trim();
2266                         //
2267                         // skip empty line, comment (start with //)
2268                         //
2269                         if (str.length() == 0 || str.startsWith("//")) {
2270                             continue;
2271                         }
2272
2273                         if (str.startsWith("Name")) {
2274                             int firstQuote = str.indexOf("\"");
2275                             int lastQuote = str.lastIndexOf("\"");
2276                             fileName = str.substring(firstQuote + 1, lastQuote);
2277                             fileNameFound = true;
2278                         }
2279
2280                         if (str.startsWith("Region")) {
2281                             int firstQuote = str.indexOf("\"");
2282                             int lastQuote = str.lastIndexOf("\"");
2283                             fvName = str.substring(firstQuote + 1, lastQuote);
2284                             fvFound = true;
2285                         }
2286
2287                         if (fileNameFound && fvFound) {
2288                             break;
2289                         }
2290                     }
2291
2292                     for (int i = 0; i <vFvInfo.size(); ++i) {
2293                         if (vFvInfo.get(i).getFvName().equals(fvName)) {
2294                             vFvInfo.get(i).setEfiFileName(fileName);
2295                         }
2296                     }
2297                 }
2298
2299             }
2300
2301             reader.close();
2302             in.close();
2303         }
2304         catch (Exception e) {
2305
2306         }
2307
2308     }
2309
2310     private class ModuleOrderPane extends JPanel {
2311
2312         /**
2313          *
2314          */
2315         private static final long serialVersionUID = 1L;
2316         private JPanel jPanelModOrderN = null;
2317         private JPanel jPanelModOrderS = null;
2318         private JPanel jPanelModOrderC = null;
2319         private JScrollPane jScrollPaneModInFv = null;
2320         private JTable jTableModInFv = null;
2321         private JPanel jPanelController = null;
2322         private JScrollPane jScrollPaneFpdModules = null;
2323         private JTable jTableFpdModules = null;
2324         private JButton jButtonUp = null;
2325         private JButton jButtonInsert = null;
2326         private JButton jButtonRemove = null;
2327         private JButton jButtonDown = null;
2328         private JButton jButtonOk = null;
2329         private JButton jButtonCancel = null;
2330         private NonEditableTableModel modInFvTableModel = null;
2331         private NonEditableTableModel fpdModTableModel = null;
2332         private HashMap<String, ModuleIdentification> mGuidToModuleId = null;
2333         private ArrayList<String> listModGuidInFv = null;
2334         private String title = null;
2335         private String outputFileName = null;
2336
2337         public ModuleOrderPane(String tabTitle, String file) {
2338             super(new BorderLayout());
2339             title = tabTitle;
2340             outputFileName = file;
2341             mGuidToModuleId = new HashMap<String, ModuleIdentification>();
2342             listModGuidInFv = new ArrayList<String>();
2343             add(getJPanelModOrderN(), java.awt.BorderLayout.NORTH);
2344             add(getJPanelModOrderS(), java.awt.BorderLayout.SOUTH);
2345             add(getJPanelModOrderC(), java.awt.BorderLayout.CENTER);
2346             showModulesInFv(title);
2347             showAllModulesInPlatform();
2348         }
2349
2350         private void showModulesInFv(String fvName) {
2351             int size = ffc.getUserExtsIncModCount(fvName);
2352
2353             if (size != -1) {
2354                 String[][] saa = new String[size][2];
2355                 ffc.getUserExtsIncMods(fvName, saa);
2356
2357                 for (int i = 0; i < size; ++i) {
2358                     listModGuidInFv.add(saa[i][0].toLowerCase());
2359                     String name = getModuleName(saa[i][0]);
2360                     String[] row = { name };
2361                     modInFvTableModel.addRow(row);
2362                 }
2363             }
2364             //
2365             // From ModuleSAs, get module guids with FvBinding = fvName.
2366             //
2367             Vector<String> vGuid = new Vector<String>();
2368             ffc.getFrameworkModuleGuid(fvName, vGuid);
2369             //
2370             // If BuildOptions->UserExtensions already contain these module info,
2371             // no need to add them into table again.
2372             //
2373             Iterator<String> iter = vGuid.iterator();
2374             while (iter.hasNext()){
2375                 String guid = iter.next();
2376 //                String moduleName = getModuleName(guid);
2377 //                if (existedInTable(moduleName, modInFvTableModel)) {
2378 //                    vGuid.remove(guid);
2379 //                }
2380                 if (!listModGuidInFv.contains(guid.toLowerCase())) {
2381                     String[] row = {getModuleName(guid)};
2382                     modInFvTableModel.addRow(row);
2383                 }
2384             }
2385
2386         }
2387
2388         private void showAllModulesInPlatform() {
2389             int size = ffc.getFrameworkModulesCount();
2390             String[][] saa = new String[size][5];
2391             ffc.getFrameworkModulesInfo(saa);
2392
2393             for (int i = 0; i < size; ++i) {
2394                 String name = getModuleName(saa[i][0]);
2395                 if (existedInTable(name, modInFvTableModel) || existedInTable(name, fpdModTableModel)) {
2396                     continue;
2397                 }
2398                 String[] row = {name};
2399                 fpdModTableModel.addRow(row);
2400             }
2401
2402             TableSorter sorter = (TableSorter)jTableFpdModules.getModel();
2403             sorter.setSortState(0, TableSorter.ASCENDING);
2404         }
2405
2406         private String getModuleName (String guid) {
2407
2408             for (int i = 0; i < GlobalData.vModuleList.size(); ++i) {
2409                 ModuleIdentification mi = GlobalData.vModuleList.get(i);
2410                 String mg = mi.getGuid();
2411                 if (mg == null) {
2412                     continue;
2413                 }
2414                 if (mg.equalsIgnoreCase(guid)) {
2415                     mGuidToModuleId.put(guid.toLowerCase(), mi);
2416                     return mi.getName();
2417                 }
2418             }
2419
2420             return "";
2421         }
2422
2423         private boolean existedInTable (String name, DefaultTableModel model) {
2424             int size = model.getDataVector().size();
2425             for (int i = 0; i < size; ++i) {
2426                 if (((Vector)model.getDataVector().elementAt(i)).contains(name)) {
2427                     return true;
2428                 }
2429             }
2430             return false;
2431         }
2432
2433
2434
2435         /**
2436          * This method initializes jPanelModOrderN
2437          *
2438          * @return javax.swing.JPanel
2439          */
2440         private JPanel getJPanelModOrderN() {
2441             if (jPanelModOrderN == null) {
2442                 jPanelModOrderN = new JPanel();
2443             }
2444             return jPanelModOrderN;
2445         }
2446
2447         /**
2448          * This method initializes jPanelModOrderS
2449          *
2450          * @return javax.swing.JPanel
2451          */
2452         private JPanel getJPanelModOrderS() {
2453             if (jPanelModOrderS == null) {
2454                 FlowLayout flowLayout6 = new FlowLayout();
2455                 flowLayout6.setAlignment(java.awt.FlowLayout.RIGHT);
2456                 jPanelModOrderS = new JPanel();
2457                 jPanelModOrderS.setLayout(flowLayout6);
2458                 jPanelModOrderS.add(getJButtonOk(), null);
2459                 jPanelModOrderS.add(getJButtonCancel(), null);
2460             }
2461             return jPanelModOrderS;
2462         }
2463
2464         /**
2465          * This method initializes jPanelModOrderC
2466          *
2467          * @return javax.swing.JPanel
2468          */
2469         private JPanel getJPanelModOrderC() {
2470             if (jPanelModOrderC == null) {
2471                 jPanelModOrderC = new JPanel();
2472                 jPanelModOrderC.add(getJScrollPaneModInFv(), null);
2473                 jPanelModOrderC.add(getJPanelController(), null);
2474                 jPanelModOrderC.add(getJScrollPaneFpdModules(), null);
2475             }
2476             return jPanelModOrderC;
2477         }
2478
2479         /**
2480          * This method initializes jScrollPaneModInFv
2481          *
2482          * @return javax.swing.JScrollPane
2483          */
2484         private JScrollPane getJScrollPaneModInFv() {
2485             if (jScrollPaneModInFv == null) {
2486                 jScrollPaneModInFv = new JScrollPane();
2487                 jScrollPaneModInFv.setPreferredSize(new java.awt.Dimension(200,500));
2488                 jScrollPaneModInFv.setViewportView(getJTableModInFv());
2489             }
2490             return jScrollPaneModInFv;
2491         }
2492
2493         /**
2494          * This method initializes jTableModInFv
2495          *
2496          * @return javax.swing.JTable
2497          */
2498         private JTable getJTableModInFv() {
2499             if (jTableModInFv == null) {
2500                 modInFvTableModel = new NonEditableTableModel();
2501                 modInFvTableModel.addColumn("Module Orders in FV");
2502                 jTableModInFv = new JTable(modInFvTableModel);
2503                 jTableModInFv.setRowHeight(20);
2504                 jTableModInFv.setShowGrid(false);
2505
2506             }
2507             return jTableModInFv;
2508         }
2509
2510         /**
2511          * This method initializes jPanelController
2512          *
2513          * @return javax.swing.JPanel
2514          */
2515         private JPanel getJPanelController() {
2516             if (jPanelController == null) {
2517                 FlowLayout flowLayout5 = new FlowLayout();
2518                 flowLayout5.setVgap(50);
2519                 flowLayout5.setHgap(50);
2520                 jPanelController = new JPanel();
2521                 jPanelController.setLayout(flowLayout5);
2522                 jPanelController.setPreferredSize(new java.awt.Dimension(150,500));
2523                 jPanelController.add(getJButtonUp(), null);
2524                 jPanelController.add(getJButtonInsert(), null);
2525                 jPanelController.add(getJButtonRemove(), null);
2526                 jPanelController.add(getJButtonDown(), null);
2527             }
2528             return jPanelController;
2529         }
2530
2531         /**
2532          * This method initializes jScrollPaneFpdModules
2533          *
2534          * @return javax.swing.JScrollPane
2535          */
2536         private JScrollPane getJScrollPaneFpdModules() {
2537             if (jScrollPaneFpdModules == null) {
2538                 jScrollPaneFpdModules = new JScrollPane();
2539                 jScrollPaneFpdModules.setPreferredSize(new java.awt.Dimension(200,500));
2540                 jScrollPaneFpdModules.setViewportView(getJTableFpdModules());
2541             }
2542             return jScrollPaneFpdModules;
2543         }
2544
2545         /**
2546          * This method initializes jTableFpdModules
2547          *
2548          * @return javax.swing.JTable
2549          */
2550         private JTable getJTableFpdModules() {
2551             if (jTableFpdModules == null) {
2552                 fpdModTableModel = new NonEditableTableModel();
2553                 TableSorter sorter = new TableSorter(fpdModTableModel);
2554                 jTableFpdModules = new JTable(sorter);
2555                 jTableFpdModules.setRowHeight(20);
2556                 jTableFpdModules.setShowGrid(false);
2557                 fpdModTableModel.addColumn("Modules in Platform");
2558
2559             }
2560             return jTableFpdModules;
2561         }
2562
2563         /**
2564          * This method initializes jButtonUp
2565          *
2566          * @return javax.swing.JButton
2567          */
2568         private JButton getJButtonUp() {
2569             if (jButtonUp == null) {
2570                 jButtonUp = new JButton();
2571                 jButtonUp.setPreferredSize(new java.awt.Dimension(60,20));
2572                 jButtonUp.setFont(new java.awt.Font("Dialog", java.awt.Font.BOLD, 14));
2573                 jButtonUp.setText("^");
2574                 jButtonUp.addActionListener(new java.awt.event.ActionListener() {
2575                     public void actionPerformed(java.awt.event.ActionEvent e) {
2576                         int selectedRow = jTableModInFv.getSelectedRow();
2577                         if (selectedRow <= 0) {
2578                             return;
2579                         }
2580                         modInFvTableModel.moveRow(selectedRow, selectedRow, selectedRow - 1);
2581                         jTableModInFv.changeSelection(selectedRow - 1, 0, false, false);
2582                     }
2583                 });
2584             }
2585             return jButtonUp;
2586         }
2587
2588         /**
2589          * This method initializes jButtonInsert
2590          *
2591          * @return javax.swing.JButton
2592          */
2593         private JButton getJButtonInsert() {
2594             if (jButtonInsert == null) {
2595                 jButtonInsert = new JButton();
2596                 jButtonInsert.setText("<<");
2597                 jButtonInsert.setPreferredSize(new java.awt.Dimension(60,20));
2598                 jButtonInsert.addActionListener(new java.awt.event.ActionListener() {
2599                     public void actionPerformed(java.awt.event.ActionEvent e) {
2600                         int selectedRowRight = jTableFpdModules.getSelectedRow();
2601                         if (selectedRowRight < 0) {
2602                             return;
2603                         }
2604
2605                         int rowInModel = ((TableSorter)jTableFpdModules.getModel()).getModelRowIndex(selectedRowRight);
2606
2607                         String[] row = {jTableFpdModules.getValueAt(selectedRowRight, 0)+""};
2608                         int selectedRowLeft = jTableModInFv.getSelectedRow();
2609                         if (selectedRowLeft < 0) {
2610                             modInFvTableModel.addRow(row);
2611                             jTableModInFv.changeSelection(jTableModInFv.getRowCount() - 1, 0, false, false);
2612                         }
2613                         else {
2614                             modInFvTableModel.insertRow(selectedRowLeft, row);
2615                             jTableModInFv.changeSelection(selectedRowLeft, 0, false, false);
2616                         }
2617                         fpdModTableModel.removeRow(rowInModel);
2618                     }
2619                 });
2620             }
2621             return jButtonInsert;
2622         }
2623
2624         /**
2625          * This method initializes jButtonRemove
2626          *
2627          * @return javax.swing.JButton
2628          */
2629         private JButton getJButtonRemove() {
2630             if (jButtonRemove == null) {
2631                 jButtonRemove = new JButton();
2632                 jButtonRemove.setPreferredSize(new java.awt.Dimension(60,20));
2633                 jButtonRemove.setText(">>");
2634                 jButtonRemove.addActionListener(new java.awt.event.ActionListener() {
2635                     public void actionPerformed(java.awt.event.ActionEvent e) {
2636                         int selectedRowLeft = jTableModInFv.getSelectedRow();
2637                         if (selectedRowLeft < 0) {
2638                             return;
2639                         }
2640
2641                         String[] row = {jTableModInFv.getValueAt(selectedRowLeft, 0)+""};
2642                         fpdModTableModel.addRow(row);
2643                         int viewIndex = ((TableSorter) jTableFpdModules.getModel()).getViewIndexArray()[jTableFpdModules
2644                                                                                                                         .getRowCount() - 1];
2645                         jTableFpdModules.changeSelection(viewIndex, 0, false, false);
2646                         modInFvTableModel.removeRow(selectedRowLeft);
2647                     }
2648                 });
2649             }
2650             return jButtonRemove;
2651         }
2652
2653         /**
2654          * This method initializes jButtonDown
2655          *
2656          * @return javax.swing.JButton
2657          */
2658         private JButton getJButtonDown() {
2659             if (jButtonDown == null) {
2660                 jButtonDown = new JButton();
2661                 jButtonDown.setPreferredSize(new java.awt.Dimension(60,20));
2662                 jButtonDown.setFont(new java.awt.Font("Dialog", java.awt.Font.BOLD, 10));
2663                 jButtonDown.setText("v");
2664                 jButtonDown.addActionListener(new java.awt.event.ActionListener() {
2665                     public void actionPerformed(java.awt.event.ActionEvent e) {
2666                         int selectedRow = jTableModInFv.getSelectedRow();
2667                         if (selectedRow >= jTableModInFv.getRowCount() - 1) {
2668                             return;
2669                         }
2670                         modInFvTableModel.moveRow(selectedRow, selectedRow, selectedRow + 1);
2671                         jTableModInFv.changeSelection(selectedRow + 1, 0, false, false);
2672                     }
2673                 });
2674             }
2675             return jButtonDown;
2676         }
2677
2678         /**
2679          * This method initializes jButtonOk
2680          *
2681          * @return javax.swing.JButton
2682          */
2683         private JButton getJButtonOk() {
2684             if (jButtonOk == null) {
2685                 jButtonOk = new JButton();
2686                 jButtonOk.setPreferredSize(new java.awt.Dimension(80,20));
2687                 jButtonOk.setText("Ok");
2688                 jButtonOk.addActionListener(new java.awt.event.ActionListener() {
2689                     public void actionPerformed(java.awt.event.ActionEvent e) {
2690                         // need reset FvBindings in ModuleSA.
2691                         ffc.removeFvBindingAll(title);
2692                         //
2693                         // collect module order information to store them into <BuildOptions> -> <UserExtensions>.
2694                         // also update the FvBinding info in <ModuleSA>.
2695                         //
2696                         Vector<String[]> vModInFv = new Vector<String[]>();
2697                         for (int i = 0; i < jTableModInFv.getRowCount(); ++i) {
2698                             String moduleName = jTableModInFv.getValueAt(i, 0)+"";
2699                             if (moduleName.length() == 0) {
2700                                 continue;
2701                             }
2702                             ModuleIdentification mi = null;
2703                             Set<String> key = mGuidToModuleId.keySet();
2704                             Iterator<String> iter = key.iterator();
2705                             while (iter.hasNext()) {
2706                                 String guid = iter.next();
2707                                 mi = mGuidToModuleId.get(guid);
2708                                 if (mi.getName().equals(moduleName)) {
2709                                     String[] sa = {guid, WorkspaceProfile.getModuleBaseName(mi)};
2710                                     vModInFv.add(sa);
2711                                     ffc.updateFvBindingInModuleSA (mi, title);
2712                                     break;
2713                                 }
2714                             }
2715
2716                         }
2717                         ffc.removeBuildOptionsUserExtensions(title);
2718                         ffc.genBuildOptionsUserExtensions(title, outputFileName, vModInFv);
2719
2720                         docConsole.setSaved(false);
2721                         jTabbedPane.setSelectedIndex(0);
2722                     }
2723                 });
2724             }
2725             return jButtonOk;
2726         }
2727
2728         /**
2729          * This method initializes jButtonCancel
2730          *
2731          * @return javax.swing.JButton
2732          */
2733         private JButton getJButtonCancel() {
2734             if (jButtonCancel == null) {
2735                 jButtonCancel = new JButton();
2736                 jButtonCancel.setPreferredSize(new java.awt.Dimension(80,20));
2737                 jButtonCancel.setText("Cancel");
2738                 jButtonCancel.addActionListener(new java.awt.event.ActionListener() {
2739                     public void actionPerformed(java.awt.event.ActionEvent e) {
2740                         jTabbedPane.setSelectedIndex(0);
2741                     }
2742                 });
2743             }
2744             return jButtonCancel;
2745         }
2746     }
2747
2748 }  //  @jve:decl-index=0:visual-constraint="10,10"
2749
2750 class FvOptsTableModel extends DefaultTableModel {
2751
2752     private static final long serialVersionUID = 1L;
2753
2754     private Vector<Object> vNonEditableName = new Vector<Object>();
2755     private Vector<Object> vKeyWords = new Vector<Object>();
2756
2757     public boolean isCellEditable(int row, int col) {
2758         if (vNonEditableName.size() > 0 || vKeyWords.size() > 0) {
2759             if (vKeyWords.contains(getValueAt(row, 0))) {
2760                 return false;
2761             }
2762             if (vNonEditableName.contains(getValueAt(row, 0)) && col == 0) {
2763                 return false;
2764             }
2765         }
2766
2767         return true;
2768     }
2769
2770     /**
2771      * @return Returns the vKeyWords.
2772      */
2773     protected Vector<Object> getVKeyWords() {
2774         return vKeyWords;
2775     }
2776
2777     /**
2778      * @param keyWords The vKeyWords to set.
2779      */
2780     protected void setVKeyWords(Vector<Object> keyWords) {
2781         vKeyWords.removeAllElements();
2782         vKeyWords.addAll(keyWords);
2783     }
2784
2785     /**
2786      * @return Returns the vNonEditableName.
2787      */
2788     protected Vector<Object> getVNonEditableName() {
2789         return vNonEditableName;
2790     }
2791
2792     /**
2793      * @param nonEditableName The vNonEditableName to set.
2794      */
2795     protected void setVNonEditableName(Vector<Object> nonEditableName) {
2796         vNonEditableName.removeAllElements();
2797         vNonEditableName.addAll(nonEditableName);
2798     }
2799
2800 }
2801 class ImageParaTableModel extends DefaultTableModel {
2802
2803     private static final long serialVersionUID = 1L;
2804
2805    public boolean isCellEditable(int row, int col) {
2806 //        if (getValueAt(row, 1).equals("ImageName") && col >=1) {
2807 //            return false;
2808 //        }
2809 //        return true;
2810        return false;
2811     }
2812 }
2813
2814 class FvInfoFromFdf {
2815     private String fvName;
2816     private String size;
2817     private String efiFileName;
2818
2819     public FvInfoFromFdf () {
2820         fvName = "";
2821         size = "";
2822         efiFileName = "";
2823     }
2824     public FvInfoFromFdf (String f, String s, String e) {
2825         this();
2826         fvName = f;
2827         size = s;
2828         efiFileName = e;
2829     }
2830     public String getEfiFileName() {
2831         return efiFileName;
2832     }
2833     public void setEfiFileName(String efiFileName) {
2834         this.efiFileName = efiFileName;
2835     }
2836     public String getFvName() {
2837         return fvName;
2838     }
2839     public void setFvName(String fvName) {
2840         this.fvName = fvName;
2841     }
2842     public String getSize() {
2843         return size;
2844     }
2845     public void setSize(String size) {
2846         this.size = size;
2847     }
2848
2849 }