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

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