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

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