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