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