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

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