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

   1 /** @file
   2   Java class FpdFlash is GUI for Flash element operation in SPD file.
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13 package org.tianocore.frameworkwizard.platform.ui;
  14
  15 import java.awt.BorderLayout;
  16 import javax.swing.JPanel;
  17
  18 import javax.swing.AbstractAction;
  19 import javax.swing.DefaultCellEditor;
  20 import javax.swing.JComponent;
  21 import javax.swing.JFileChooser;
  22 import javax.swing.JFrame;
  23 import javax.swing.JOptionPane;
  24 import javax.swing.JTabbedPane;
  25 import javax.swing.JButton;
  26 import javax.swing.ListSelectionModel;
  27
  28 import org.tianocore.PlatformSurfaceAreaDocument;
  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
  33
  34 import java.awt.FlowLayout;
  35 import java.awt.event.ActionEvent;
  36 import java.awt.event.ComponentAdapter;
  37 import java.awt.event.ComponentEvent;
  38 import java.awt.event.ItemEvent;
  39 import java.awt.event.ItemListener;
  40 import java.io.BufferedReader;
  41 import java.io.File;
  42 import java.io.FileReader;
  43 import java.util.Iterator;
  44 import java.util.LinkedHashMap;
  45 import java.util.Map;
  46 import java.util.Set;
  47 import java.util.Vector;
  48
  49 import javax.swing.JCheckBox;
  50 import javax.swing.JTextField;
  51 import java.awt.GridLayout;
  52 import javax.swing.JLabel;
  53 import javax.swing.JScrollPane;
  54 import javax.swing.JTable;
  55 import javax.swing.event.InternalFrameAdapter;
  56 import javax.swing.event.InternalFrameEvent;
  57 import javax.swing.event.ListSelectionEvent;
  58 import javax.swing.event.ListSelectionListener;
  59 import javax.swing.event.TableModelEvent;
  60 import javax.swing.event.TableModelListener;
  61 import javax.swing.table.DefaultTableModel;
  62 import javax.swing.table.TableColumn;
  63 import javax.swing.table.TableModel;
  64 import javax.swing.JComboBox;
  65 import java.awt.Dimension;
  66 import javax.swing.JSplitPane;
  67
  68 public class FpdFlash extends IInternalFrame {
  69
  70     /**
  71      *
  72      */
  73     private static final long serialVersionUID = 1L;
  74     static JFrame frame;
  75     private JPanel jContentPane = null;
  76     private JPanel jPanelContentEast = null;
  77     private JPanel jPanelContentSouth = null;
  78     private JPanel jPanelContentWest = null;
  79     private JPanel jPanelContentNorth = null;
  80     private JTabbedPane jTabbedPane = null;
  81     private JPanel jPanelFvImages = null;
  82     private JPanel jPanelFvImageN = null;
  83     private JPanel jPanelFvImageS = null;
  84     private JCheckBox jCheckBoxFvProperty = null;
  85     private JLabel jLabelFvPropName = null;
  86     private JTextField jTextFieldFvPropName = null;
  87     private JLabel jLabelFvPropValue = null;
  88     private JTextField jTextFieldFvPropValue = null;
  89     private JButton jButtonFvPropAdd = null;
  90     private JScrollPane jScrollPaneFvProp = null;
  91     private JTable jTableFvProp = null;
  92     private JPanel jPanelFvPropButtonGroup = null;
  93     private JButton jButtonFvPropDel = null;
  94     private DefaultTableModel fvPropertyTableModel = null;
  95     private DefaultTableModel fvImageNameTableModel = null;
  96     private ImageParaTableModel fvImageParaTableModel = null;
  97     private DefaultTableModel fvOptionTableModel = null;
  98     private JPanel jPanelFvImageC = null;
  99     private JCheckBox jCheckBoxFvImagePara = null;
 100     private JLabel jLabelFvParaType = null;
 101     private JComboBox jComboBoxFvParaType = null;
 102     private JLabel jLabelFvImageNames = null;
 103     private JLabel jLabelFvParaName = null;
 104     private JTextField jTextFieldFvParaName = null;
 105     private JButton jButtonFvParaAdd = null;
 106     private JScrollPane jScrollPaneFvImageNames = null;
 107     private JTable jTableFvImageNames = null;
 108     private JButton jButtonFvParaDel = null;
 109     private JPanel jPanelFvImageOpts = null;
 110     private JButton jButtonAddFvImage = null;
 111     private JScrollPane jScrollPaneFvInfo = null;
 112     private JTable jTableFvInfo = null;
 113     private JButton jButtonDelFvImage = null;
 114     private JCheckBox jCheckBoxFvImageOpts = null;
 115     private JPanel jPanelFvImagePara = null;
 116     private OpeningPlatformType docConsole = null;
 117     private FpdFileContents ffc = null;
 118     private JPanel jPanelFdf = null;
 119     private JCheckBox jCheckBoxFdf = null;
 120     private JTextField jTextFieldFdf = null;
 121     private JButton jButtonFdfBrowse = null;
 122     private JLabel jLabelFvImageOptName = null;
 123     private JTextField jTextFieldFvImageOptName = null;
 124     private JLabel jLabelFvImageOptValue = null;
 125     private JTextField jTextFieldFvImageOptValue = null;
 126     private JPanel jPanelFvImageOptsButtonGroup = null;
 127     private JButton jButtonFvImageOptAdd = null;
 128     private JButton jButtonFvImageOptDel = null;
 129     private JScrollPane jScrollPane = null;
 130     private JTable jTableFvImageOpts = null;
 131     private JButton jButtonUpdateFvImage = null;
 132     private JButton jButtonTest = null;
 133     private JPanel jPanelFdfN = null;
 134     private JPanel jPanelFdfS = null;
 135     private JSplitPane jSplitPaneFdfC = null;
 136     private JPanel jPanelFdfCTop = null;
 137     private JPanel jPanelFdfCBottom = null;
 138     private JPanel jPanelFdfCTopN = null;
 139     private JPanel jPanelFdfCTopS = null;
 140     private JPanel jPanelFdfCTopC = null;
 141     private JPanel jPanelFdfCBottomN = null;
 142     private JPanel jPanelFdfCBottomC = null;
 143     private JLabel jLabelFvInFdf = null;
 144     private JLabel jLabelFvAdditional = null;
 145     private JScrollPane jScrollPaneFvInFdf = null;
 146     private JTable jTableFvInFdf = null;
 147     private NonEditableTableModel fvInFdfTableModel = null;  //  @jve:decl-index=0:visual-constraint=""
 148     private JButton jButtonFvInFdfOptions = null;
 149     private JScrollPane jScrollPaneFvAdditional = null;
 150     private JTable jTableFvAdditional = null;
 151     private DefaultTableModel fvAddtionalTableModel = null;  //  @jve:decl-index=0:visual-constraint=""
 152     private JButton jButtonAddFv = null;
 153     private JButton jButtonDelFv = null;
 154     private JButton jButtonAddFvOptions = null;
 155
 156     private NonEditableTableModel nonEditableTableModel = null;  //  @jve:decl-index=0:visual-constraint=""
 157
 158     private JPanel jPanelModOrder = null;
 159     private JPanel jPanelModOrderN = null;
 160     private JPanel jPanelModOrderS = null;
 161     private JPanel jPanelModOrderC = null;
 162     private JScrollPane jScrollPaneModInFv = null;
 163     private JTable jTableModInFv = null;
 164     private JPanel jPanelController = null;
 165     private JScrollPane jScrollPaneFpdModules = null;
 166     private JTable jTableFpdModules = null;
 167     private JButton jButtonUp = null;
 168     private JButton jButtonInsert = null;
 169     private JButton jButtonRemove = null;
 170     private JButton jButtonDown = null;
 171     private JButton jButtonOk = null;
 172     private JButton jButtonCancel = null;
 173
 174     /**
 175      * This method initializes jPanelModOrder
 176      *
 177      * @return javax.swing.JPanel
 178      */
 179     private JPanel getJPanelModOrder() {
 180 //        if (jPanelModOrder == null) {
 181             jPanelModOrder = new JPanel();
 182             jPanelModOrder.setLayout(new BorderLayout());
 183             jPanelModOrder.add(getJPanelModOrderN(), java.awt.BorderLayout.NORTH);
 184             jPanelModOrder.add(getJPanelModOrderS(), java.awt.BorderLayout.SOUTH);
 185             jPanelModOrder.add(getJPanelModOrderC(), java.awt.BorderLayout.CENTER);
 186             jPanelModOrder.addComponentListener(new java.awt.event.ComponentAdapter() {
 187                 public void componentShown(java.awt.event.ComponentEvent e) {
 188                     System.out.println("componentShown()" + jTabbedPane.getTitleAt(jTabbedPane.getSelectedIndex())); // TODO Auto-generated Event stub componentShown()
 189                 }
 190             });
 191 //        }
 192         return jPanelModOrder;
 193     }
 194
 195     /**
 196      * This method initializes jPanelModOrderN
 197      *
 198      * @return javax.swing.JPanel
 199      */
 200     private JPanel getJPanelModOrderN() {
 201 //        if (jPanelModOrderN == null) {
 202             jPanelModOrderN = new JPanel();
 203 //        }
 204         return jPanelModOrderN;
 205     }
 206
 207     /**
 208      * This method initializes jPanelModOrderS
 209      *
 210      * @return javax.swing.JPanel
 211      */
 212     private JPanel getJPanelModOrderS() {
 213 //        if (jPanelModOrderS == null) {
 214             FlowLayout flowLayout6 = new FlowLayout();
 215             flowLayout6.setAlignment(java.awt.FlowLayout.RIGHT);
 216             jPanelModOrderS = new JPanel();
 217             jPanelModOrderS.setLayout(flowLayout6);
 218             jPanelModOrderS.add(getJButtonOk(), null);
 219             jPanelModOrderS.add(getJButtonCancel(), null);
 220 //        }
 221         return jPanelModOrderS;
 222     }
 223
 224     /**
 225      * This method initializes jPanelModOrderC
 226      *
 227      * @return javax.swing.JPanel
 228      */
 229     private JPanel getJPanelModOrderC() {
 230 //        if (jPanelModOrderC == null) {
 231             jPanelModOrderC = new JPanel();
 232             jPanelModOrderC.add(getJScrollPaneModInFv(), null);
 233             jPanelModOrderC.add(getJPanelController(), null);
 234             jPanelModOrderC.add(getJScrollPaneFpdModules(), null);
 235 //        }
 236         return jPanelModOrderC;
 237     }
 238
 239     /**
 240      * This method initializes jScrollPaneModInFv
 241      *
 242      * @return javax.swing.JScrollPane
 243      */
 244     private JScrollPane getJScrollPaneModInFv() {
 245 //        if (jScrollPaneModInFv == null) {
 246             jScrollPaneModInFv = new JScrollPane();
 247             jScrollPaneModInFv.setPreferredSize(new java.awt.Dimension(150,500));
 248             jScrollPaneModInFv.setViewportView(getJTableModInFv());
 249 //        }
 250         return jScrollPaneModInFv;
 251     }
 252
 253     /**
 254      * This method initializes jTableModInFv
 255      *
 256      * @return javax.swing.JTable
 257      */
 258     private JTable getJTableModInFv() {
 259 //        if (jTableModInFv == null) {
 260             NonEditableTableModel modInFvTableModel = new NonEditableTableModel();
 261             modInFvTableModel.addColumn("Module Orders in FV");
 262             jTableModInFv = new JTable(modInFvTableModel);
 263             jTableModInFv.setRowHeight(20);
 264 //        }
 265         return jTableModInFv;
 266     }
 267
 268     /**
 269      * This method initializes jPanelController
 270      *
 271      * @return javax.swing.JPanel
 272      */
 273     private JPanel getJPanelController() {
 274 //        if (jPanelController == null) {
 275             FlowLayout flowLayout5 = new FlowLayout();
 276             flowLayout5.setVgap(50);
 277             flowLayout5.setHgap(50);
 278             jPanelController = new JPanel();
 279             jPanelController.setLayout(flowLayout5);
 280             jPanelController.setPreferredSize(new java.awt.Dimension(150,500));
 281             jPanelController.add(getJButtonUp(), null);
 282             jPanelController.add(getJButtonInsert(), null);
 283             jPanelController.add(getJButtonRemove(), null);
 284             jPanelController.add(getJButtonDown(), null);
 285 //        }
 286         return jPanelController;
 287     }
 288
 289     /**
 290      * This method initializes jScrollPaneFpdModules
 291      *
 292      * @return javax.swing.JScrollPane
 293      */
 294     private JScrollPane getJScrollPaneFpdModules() {
 295 //        if (jScrollPaneFpdModules == null) {
 296             jScrollPaneFpdModules = new JScrollPane();
 297             jScrollPaneFpdModules.setPreferredSize(new java.awt.Dimension(150,500));
 298             jScrollPaneFpdModules.setViewportView(getJTableFpdModules());
 299 //        }
 300         return jScrollPaneFpdModules;
 301     }
 302
 303     /**
 304      * This method initializes jTableFpdModules
 305      *
 306      * @return javax.swing.JTable
 307      */
 308     private JTable getJTableFpdModules() {
 309 //        if (jTableFpdModules == null) {
 310             NonEditableTableModel fpdModTableModel = new NonEditableTableModel();
 311             fpdModTableModel.addColumn("Modules in Platform");
 312             jTableFpdModules = new JTable(fpdModTableModel);
 313             jTableFpdModules.setRowHeight(20);
 314 //        }
 315         return jTableFpdModules;
 316     }
 317
 318     /**
 319      * This method initializes jButtonUp
 320      *
 321      * @return javax.swing.JButton
 322      */
 323     private JButton getJButtonUp() {
 324 //        if (jButtonUp == null) {
 325             jButtonUp = new JButton();
 326             jButtonUp.setPreferredSize(new java.awt.Dimension(60,20));
 327             jButtonUp.setFont(new java.awt.Font("Dialog", java.awt.Font.BOLD, 14));
 328             jButtonUp.setText("^");
 329 //        }
 330         return jButtonUp;
 331     }
 332
 333     /**
 334      * This method initializes jButtonInsert
 335      *
 336      * @return javax.swing.JButton
 337      */
 338     private JButton getJButtonInsert() {
 339 //        if (jButtonInsert == null) {
 340             jButtonInsert = new JButton();
 341             jButtonInsert.setText("<<");
 342             jButtonInsert.setPreferredSize(new java.awt.Dimension(60,20));
 343 //        }
 344         return jButtonInsert;
 345     }
 346
 347     /**
 348      * This method initializes jButtonRemove
 349      *
 350      * @return javax.swing.JButton
 351      */
 352     private JButton getJButtonRemove() {
 353 //        if (jButtonRemove == null) {
 354             jButtonRemove = new JButton();
 355             jButtonRemove.setPreferredSize(new java.awt.Dimension(60,20));
 356             jButtonRemove.setText(">>");
 357 //        }
 358         return jButtonRemove;
 359     }
 360
 361     /**
 362      * This method initializes jButtonDown
 363      *
 364      * @return javax.swing.JButton
 365      */
 366     private JButton getJButtonDown() {
 367 //        if (jButtonDown == null) {
 368             jButtonDown = new JButton();
 369             jButtonDown.setPreferredSize(new java.awt.Dimension(60,20));
 370             jButtonDown.setFont(new java.awt.Font("Dialog", java.awt.Font.BOLD, 10));
 371             jButtonDown.setText("v");
 372 //        }
 373         return jButtonDown;
 374     }
 375
 376     /**
 377      * This method initializes jButtonOk
 378      *
 379      * @return javax.swing.JButton
 380      */
 381     private JButton getJButtonOk() {
 382 //        if (jButtonOk == null) {
 383             jButtonOk = new JButton();
 384             jButtonOk.setPreferredSize(new java.awt.Dimension(80,20));
 385             jButtonOk.setText("Ok");
 386 //        }
 387         return jButtonOk;
 388     }
 389
 390     /**
 391      * This method initializes jButtonCancel
 392      *
 393      * @return javax.swing.JButton
 394      */
 395     private JButton getJButtonCancel() {
 396 //        if (jButtonCancel == null) {
 397             jButtonCancel = new JButton();
 398             jButtonCancel.setPreferredSize(new java.awt.Dimension(80,20));
 399             jButtonCancel.setText("Cancel");
 400             jButtonCancel.addActionListener(new java.awt.event.ActionListener() {
 401                 public void actionPerformed(java.awt.event.ActionEvent e) {
 402                     getJTabbedPane().setSelectedIndex(0);
 403                 }
 404             });
 405 //        }
 406         return jButtonCancel;
 407     }
 408
 409
 410     public FpdFlash() {
 411         super();
 412         // TODO Auto-generated constructor stub
 413
 414         initialize();
 415         this.setBounds(new java.awt.Rectangle(0, 0, 500, 370));
 416         this.setVisible(true);
 417     }
 418
 419     public FpdFlash(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd){
 420         this();
 421         ffc = new FpdFileContents(fpd);
 422         init(ffc);
 423     }
 424
 425     public FpdFlash(OpeningPlatformType opt) {
 426         this(opt.getXmlFpd());
 427         docConsole = opt;
 428     }
 429
 430     /**
 431      * This method initializes jPanel
 432      *
 433      * @return javax.swing.JPanel
 434      */
 435     private JPanel getJPanelContentEast() {
 436         if (jPanelContentEast == null) {
 437             jPanelContentEast = new JPanel();
 438         }
 439         return jPanelContentEast;
 440     }
 441
 442     /**
 443      * This method initializes jPanel1
 444      *
 445      * @return javax.swing.JPanel
 446      */
 447     private JPanel getJPanelContentSouth() {
 448         if (jPanelContentSouth == null) {
 449             FlowLayout flowLayout = new FlowLayout();
 450             flowLayout.setAlignment(java.awt.FlowLayout.RIGHT);
 451             flowLayout.setHgap(15);
 452             jPanelContentSouth = new JPanel();
 453             jPanelContentSouth.setLayout(flowLayout);
 454             jPanelContentSouth.setComponentOrientation(java.awt.ComponentOrientation.LEFT_TO_RIGHT);
 455         }
 456         return jPanelContentSouth;
 457     }
 458
 459     /**
 460      * This method initializes jPanel2
 461      *
 462      * @return javax.swing.JPanel
 463      */
 464     private JPanel getJPanelContentWest() {
 465         if (jPanelContentWest == null) {
 466             jPanelContentWest = new JPanel();
 467         }
 468         return jPanelContentWest;
 469     }
 470
 471     /**
 472      * This method initializes jPanel3
 473      *
 474      * @return javax.swing.JPanel
 475      */
 476     private JPanel getJPanelContentNorth() {
 477         if (jPanelContentNorth == null) {
 478             jPanelContentNorth = new JPanel();
 479         }
 480         return jPanelContentNorth;
 481     }
 482
 483     /**
 484      * This method initializes jTabbedPane
 485      *
 486      * @return javax.swing.JTabbedPane
 487      */
 488     private JTabbedPane getJTabbedPane() {
 489         if (jTabbedPane == null) {
 490             jTabbedPane = new JTabbedPane();
 491             jTabbedPane.addTab("General", null, getJPanelFdf(), null);
 492             jTabbedPane.addTab("FV Parameters", null, getJPanelFvImages(), null);
 493
 494         }
 495         return jTabbedPane;
 496     }
 497
 498     /**
 499      * This method initializes jPanelFvImages
 500      *
 501      * @return javax.swing.JPanel
 502      */
 503     private JPanel getJPanelFvImages() {
 504         if (jPanelFvImages == null) {
 505             jPanelFvImages = new JPanel();
 506             jPanelFvImages.setLayout(new BorderLayout());
 507             jPanelFvImages.add(getJPanelFvImageN(), java.awt.BorderLayout.NORTH);
 508 //            jPanelFvImages.add(getJPanelFvImageW(), java.awt.BorderLayout.WEST);
 509             jPanelFvImages.add(getJPanelFvImageS(), java.awt.BorderLayout.SOUTH);
 510             jPanelFvImages.add(getJPanelFvImageC(), java.awt.BorderLayout.CENTER);
 511
 512         }
 513         return jPanelFvImages;
 514     }
 515
 516     /**
 517      * This method initializes jPanelFvImageN
 518      *
 519      * @return javax.swing.JPanel
 520      */
 521     private JPanel getJPanelFvImageN() {
 522         if (jPanelFvImageN == null) {
 523             jLabelFvPropValue = new JLabel();
 524             jLabelFvPropValue.setText("Value");
 525             jLabelFvPropValue.setEnabled(false);
 526             jLabelFvPropValue.setPreferredSize(new java.awt.Dimension(38,20));
 527             jLabelFvPropName = new JLabel();
 528             jLabelFvPropName.setText("Name");
 529             jLabelFvPropName.setEnabled(false);
 530             jLabelFvPropName.setPreferredSize(new java.awt.Dimension(38,20));
 531             FlowLayout flowLayout2 = new FlowLayout();
 532             flowLayout2.setAlignment(java.awt.FlowLayout.LEFT);
 533             flowLayout2.setHgap(15);
 534             jPanelFvImageN = new JPanel();
 535             jPanelFvImageN.setPreferredSize(new java.awt.Dimension(576,100));
 536             jPanelFvImageN.setBorder(javax.swing.BorderFactory.createBevelBorder(javax.swing.border.BevelBorder.RAISED));
 537             jPanelFvImageN.setLayout(flowLayout2);
 538             jPanelFvImageN.add(getJCheckBoxFvProperty(), null);
 539             jPanelFvImageN.add(jLabelFvPropName, null);
 540             jPanelFvImageN.add(getJTextFieldFvPropName(), null);
 541             jPanelFvImageN.add(jLabelFvPropValue, null);
 542             jPanelFvImageN.add(getJTextFieldFvPropValue(), null);
 543             jPanelFvImageN.add(getJScrollPaneFvProp(), null);
 544             jPanelFvImageN.add(getJPanelFvPropButtonGroup(), null);
 545         }
 546         return jPanelFvImageN;
 547     }
 548
 549     /**
 550      * This method initializes jPanelFvImageS
 551      *
 552      * @return javax.swing.JPanel
 553      */
 554     private JPanel getJPanelFvImageS() {
 555         if (jPanelFvImageS == null) {
 556             GridLayout gridLayout2 = new GridLayout();
 557             gridLayout2.setRows(1);
 558             jPanelFvImageS = new JPanel();
 559             jPanelFvImageS.setPreferredSize(new java.awt.Dimension(480,190));
 560             jPanelFvImageS.setLayout(gridLayout2);
 561             jPanelFvImageS.add(getJScrollPaneFvInfo(), null);
 562         }
 563         return jPanelFvImageS;
 564     }
 565
 566
 567     /**
 568      * This method initializes jCheckBox1
 569      *
 570      * @return javax.swing.JCheckBox
 571      */
 572     private JCheckBox getJCheckBoxFvProperty() {
 573         if (jCheckBoxFvProperty == null) {
 574             jCheckBoxFvProperty = new JCheckBox();
 575             jCheckBoxFvProperty.setText("Global FV Variables");
 576             jCheckBoxFvProperty.addItemListener(new ItemListener(){
 577
 578                 public void itemStateChanged(ItemEvent arg0) {
 579                     // TODO Auto-generated method stub
 580                     boolean seleted = jCheckBoxFvProperty.isSelected();
 581
 582                         jLabelFvPropName.setEnabled(seleted);
 583                         jTextFieldFvPropName.setEnabled(seleted);
 584                         jLabelFvPropValue.setEnabled(seleted);
 585                         jTextFieldFvPropValue.setEnabled(seleted);
 586                         jTableFvProp.setEnabled(seleted);
 587                         jButtonFvPropAdd.setEnabled(seleted);
 588                         jButtonFvPropDel.setEnabled(seleted);
 589
 590
 591                 }
 592
 593             });
 594         }
 595         return jCheckBoxFvProperty;
 596     }
 597
 598
 599     /**
 600      * This method initializes jTextField
 601      *
 602      * @return javax.swing.JTextField
 603      */
 604     private JTextField getJTextFieldFvPropName() {
 605         if (jTextFieldFvPropName == null) {
 606             jTextFieldFvPropName = new JTextField();
 607             jTextFieldFvPropName.setPreferredSize(new java.awt.Dimension(100,20));
 608             jTextFieldFvPropName.setEnabled(false);
 609         }
 610         return jTextFieldFvPropName;
 611     }
 612
 613
 614     /**
 615      * This method initializes jTextField1
 616      *
 617      * @return javax.swing.JTextField
 618      */
 619     private JTextField getJTextFieldFvPropValue() {
 620         if (jTextFieldFvPropValue == null) {
 621             jTextFieldFvPropValue = new JTextField();
 622             jTextFieldFvPropValue.setPreferredSize(new java.awt.Dimension(100,20));
 623             jTextFieldFvPropValue.setEnabled(false);
 624         }
 625         return jTextFieldFvPropValue;
 626     }
 627
 628
 629     /**
 630      * This method initializes jButton
 631      *
 632      * @return javax.swing.JButton
 633      */
 634     private JButton getJButtonFvPropAdd() {
 635         if (jButtonFvPropAdd == null) {
 636             jButtonFvPropAdd = new JButton();
 637             jButtonFvPropAdd.setPreferredSize(new java.awt.Dimension(80,20));
 638             jButtonFvPropAdd.setEnabled(false);
 639             jButtonFvPropAdd.setText("Add");
 640             jButtonFvPropAdd.addActionListener(new AbstractAction() {
 641                 /**
 642                  *
 643                  */
 644                 private static final long serialVersionUID = 1L;
 645
 646                 public void actionPerformed(ActionEvent e) {
 647                     if (jTextFieldFvPropName.getText().length() > 0 && jTextFieldFvPropValue.getText().length() > 0){
 648                         String[] row = {jTextFieldFvPropName.getText(), jTextFieldFvPropValue.getText()};
 649                         fvPropertyTableModel.addRow(row);
 650                         docConsole.setSaved(false);
 651                         ffc.genFvImagesNameValue(row[0], row[1]);
 652                     }
 653                 }
 654             });
 655         }
 656         return jButtonFvPropAdd;
 657     }
 658
 659
 660     /**
 661      * This method initializes jScrollPane1
 662      *
 663      * @return javax.swing.JScrollPane
 664      */
 665     private JScrollPane getJScrollPaneFvProp() {
 666         if (jScrollPaneFvProp == null) {
 667             jScrollPaneFvProp = new JScrollPane();
 668             jScrollPaneFvProp.setPreferredSize(new java.awt.Dimension(350,55));
 669             jScrollPaneFvProp.setViewportView(getJTableFvProp());
 670         }
 671         return jScrollPaneFvProp;
 672     }
 673
 674
 675     /**
 676      * This method initializes jTable
 677      *
 678      * @return javax.swing.JTable
 679      */
 680     private JTable getJTableFvProp() {
 681         if (jTableFvProp == null) {
 682             fvPropertyTableModel = new DefaultTableModel();
 683             jTableFvProp = new JTable(fvPropertyTableModel);
 684             fvPropertyTableModel.addColumn("Name");
 685             fvPropertyTableModel.addColumn("Value");
 686             jTableFvProp.setRowHeight(20);
 687             jTableFvProp.setEnabled(false);
 688
 689             jTableFvProp.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 690             jTableFvProp.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 691                 public void valueChanged(ListSelectionEvent e) {
 692                     if (e.getValueIsAdjusting()){
 693                         return;
 694                     }
 695                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 696                     if (lsm.isSelectionEmpty()) {
 697                         return;
 698                     }
 699                     else{
 700 //                        selectedRow = lsm.getMinSelectionIndex();
 701                     }
 702                 }
 703             });
 704
 705             jTableFvProp.getModel().addTableModelListener(new TableModelListener(){
 706                 public void tableChanged(TableModelEvent arg0) {
 707                     // TODO Auto-generated method stub
 708                     int row = arg0.getFirstRow();
 709                     TableModel m = (TableModel)arg0.getSource();
 710                     if (arg0.getType() == TableModelEvent.UPDATE){
 711
 712                         String name = m.getValueAt(row, 0) + "";
 713                         String value = m.getValueAt(row, 1) + "";
 714                         docConsole.setSaved(false);
 715                         ffc.updateFvImagesNameValue(row, name, value);
 716                     }
 717                 }
 718             });
 719         }
 720         return jTableFvProp;
 721     }
 722
 723
 724     /**
 725      * This method initializes jPanel4
 726      *
 727      * @return javax.swing.JPanel
 728      */
 729     private JPanel getJPanelFvPropButtonGroup() {
 730         if (jPanelFvPropButtonGroup == null) {
 731             jPanelFvPropButtonGroup = new JPanel();
 732             jPanelFvPropButtonGroup.setPreferredSize(new java.awt.Dimension(80,55));
 733
 734             jPanelFvPropButtonGroup.add(getJButtonFvPropAdd(), null);
 735             jPanelFvPropButtonGroup.add(getJButtonFvPropDel(), null);
 736         }
 737         return jPanelFvPropButtonGroup;
 738     }
 739
 740
 741     /**
 742      * This method initializes jButton1
 743      *
 744      * @return javax.swing.JButton
 745      */
 746     private JButton getJButtonFvPropDel() {
 747         if (jButtonFvPropDel == null) {
 748             jButtonFvPropDel = new JButton();
 749             jButtonFvPropDel.setPreferredSize(new java.awt.Dimension(80,20));
 750             jButtonFvPropDel.setEnabled(false);
 751             jButtonFvPropDel.setText("Delete");
 752             jButtonFvPropDel.addActionListener(new AbstractAction() {
 753                 /**
 754                  *
 755                  */
 756                 private static final long serialVersionUID = 1L;
 757
 758                 public void actionPerformed(ActionEvent e) {
 759                     if (jTableFvProp.getSelectedRow() >= 0){
 760                         fvPropertyTableModel.removeRow(jTableFvProp.getSelectedRow());
 761                         docConsole.setSaved(false);
 762                         ffc.removeFvImagesNameValue(jTableFvProp.getSelectedRow());
 763                     }
 764                 }
 765             });
 766         }
 767         return jButtonFvPropDel;
 768     }
 769
 770
 771     /**
 772      * This method initializes jPanelFvImageC
 773      *
 774      * @return javax.swing.JPanel
 775      */
 776     private JPanel getJPanelFvImageC() {
 777         if (jPanelFvImageC == null) {
 778             jLabelFvParaName = new JLabel();
 779             jLabelFvParaName.setPreferredSize(new Dimension(38, 20));
 780             jLabelFvParaName.setEnabled(false);
 781             jLabelFvParaName.setText("Name");
 782             jLabelFvImageNames = new JLabel();
 783             jLabelFvImageNames.setText("FV Image Names");
 784             jLabelFvImageNames.setEnabled(false);
 785             jLabelFvImageNames.setPreferredSize(new java.awt.Dimension(150,20));
 786             jLabelFvParaType = new JLabel();
 787             jLabelFvParaType.setText("Type");
 788             jLabelFvParaType.setEnabled(false);
 789             jLabelFvParaType.setPreferredSize(new java.awt.Dimension(70,20));
 790             FlowLayout flowLayout3 = new FlowLayout();
 791             flowLayout3.setAlignment(java.awt.FlowLayout.LEFT);
 792             flowLayout3.setHgap(5);
 793             jPanelFvImageC = new JPanel();
 794             jPanelFvImageC.setLayout(flowLayout3);
 795             jPanelFvImageC.add(getJPanelFvImagePara(), null);
 796
 797             jPanelFvImageC.add(getJPanelFvImageOpts(), null);
 798
 799         }
 800         return jPanelFvImageC;
 801     }
 802
 803
 804     /**
 805      * This method initializes jCheckBox2
 806      *
 807      * @return javax.swing.JCheckBox
 808      */
 809     private JCheckBox getJCheckBoxFvImagePara() {
 810         if (jCheckBoxFvImagePara == null) {
 811             jCheckBoxFvImagePara = new JCheckBox();
 812             jCheckBoxFvImagePara.setText("FV Image Parameters");
 813             jCheckBoxFvImagePara.setPreferredSize(new java.awt.Dimension(200,20));
 814             jCheckBoxFvImagePara.addItemListener(new ItemListener(){
 815
 816                 public void itemStateChanged(ItemEvent arg0) {
 817                     // TODO Auto-generated method stub
 818                     boolean seleted = jCheckBoxFvImagePara.isSelected();
 819
 820                         jLabelFvParaType.setEnabled(seleted);
 821                         jLabelFvImageNames.setEnabled(seleted);
 822                         jLabelFvParaName.setEnabled(seleted);
 823                         jComboBoxFvParaType.setEnabled(seleted);
 824                         jTextFieldFvParaName.setEnabled(seleted);
 825
 826                         jTableFvImageNames.setEnabled(seleted);
 827                         jButtonFvParaAdd.setEnabled(seleted);
 828                         jButtonFvParaDel.setEnabled(seleted);
 829
 830
 831                 }
 832
 833             });
 834         }
 835         return jCheckBoxFvImagePara;
 836     }
 837
 838
 839     /**
 840      * This method initializes jComboBox
 841      *
 842      * @return javax.swing.JComboBox
 843      */
 844     private JComboBox getJComboBoxFvParaType() {
 845         if (jComboBoxFvParaType == null) {
 846             jComboBoxFvParaType = new JComboBox();
 847             jComboBoxFvParaType.addItem("ImageName");
 848             jComboBoxFvParaType.addItem("Attributes");
 849             jComboBoxFvParaType.addItem("Options");
 850             jComboBoxFvParaType.addItem("Components");
 851             jComboBoxFvParaType.setPreferredSize(new java.awt.Dimension(180,20));
 852             jComboBoxFvParaType.setEnabled(false);
 853             jComboBoxFvParaType.addItemListener(new ItemListener() {
 854
 855                 public void itemStateChanged(ItemEvent arg0) {
 856                     // TODO disable attribute settings when ValidImageNames selected.
 857
 858                 }
 859
 860             });
 861         }
 862         return jComboBoxFvParaType;
 863     }
 864
 865
 866     /**
 867      * This method initializes jTextField2
 868      *
 869      * @return javax.swing.JTextField
 870      */
 871     private JTextField getJTextFieldFvParaName() {
 872         if (jTextFieldFvParaName == null) {
 873             jTextFieldFvParaName = new JTextField();
 874             jTextFieldFvParaName.setPreferredSize(new java.awt.Dimension(140,20));
 875             jTextFieldFvParaName.setEnabled(false);
 876         }
 877         return jTextFieldFvParaName;
 878     }
 879
 880
 881     /**
 882      * This method initializes jButton2
 883      *
 884      * @return javax.swing.JButton
 885      */
 886     private JButton getJButtonFvParaAdd() {
 887         if (jButtonFvParaAdd == null) {
 888             jButtonFvParaAdd = new JButton();
 889             jButtonFvParaAdd.setPreferredSize(new Dimension(80, 20));
 890             jButtonFvParaAdd.setEnabled(false);
 891             jButtonFvParaAdd.setText("Add");
 892             jButtonFvParaAdd.addActionListener(new AbstractAction() {
 893                 /**
 894                  *
 895                  */
 896                 private static final long serialVersionUID = 1L;
 897
 898                 public void actionPerformed(java.awt.event.ActionEvent e) {
 899                     if (jTextFieldFvParaName.getText().length() > 0){
 900                         String[] row = {jTextFieldFvParaName.getText()};
 901                         fvImageNameTableModel.addRow(row);
 902                     }
 903                 }
 904             });
 905         }
 906         return jButtonFvParaAdd;
 907     }
 908
 909
 910     /**
 911      * This method initializes jScrollPane2
 912      *
 913      * @return javax.swing.JScrollPane
 914      */
 915     private JScrollPane getJScrollPaneFvImageNames() {
 916         if (jScrollPaneFvImageNames == null) {
 917             jScrollPaneFvImageNames = new JScrollPane();
 918             jScrollPaneFvImageNames.setPreferredSize(new java.awt.Dimension(350,50));
 919             jScrollPaneFvImageNames.setViewportView(getJTableFvImageNames());
 920         }
 921         return jScrollPaneFvImageNames;
 922     }
 923
 924
 925     /**
 926      * This method initializes jTable1
 927      *
 928      * @return javax.swing.JTable
 929      */
 930     private JTable getJTableFvImageNames() {
 931         if (jTableFvImageNames == null) {
 932             fvImageNameTableModel = new DefaultTableModel();
 933             jTableFvImageNames = new JTable(fvImageNameTableModel);
 934             jTableFvImageNames.setEnabled(false);
 935             fvImageNameTableModel.addColumn("FV Image Name");
 936         }
 937         return jTableFvImageNames;
 938     }
 939
 940
 941     /**
 942      * This method initializes jButton3
 943      *
 944      * @return javax.swing.JButton
 945      */
 946     private JButton getJButtonFvParaDel() {
 947         if (jButtonFvParaDel == null) {
 948             jButtonFvParaDel = new JButton();
 949             jButtonFvParaDel.setPreferredSize(new Dimension(80, 20));
 950             jButtonFvParaDel.setEnabled(false);
 951             jButtonFvParaDel.setText("Delete");
 952             jButtonFvParaDel.addActionListener(new AbstractAction() {
 953                 /**
 954                  *
 955                  */
 956                 private static final long serialVersionUID = 1L;
 957
 958                 public void actionPerformed(java.awt.event.ActionEvent e) {
 959                     if (jTableFvImageNames.getSelectedRow() >= 0){
 960
 961                         fvImageNameTableModel.removeRow(jTableFvImageNames.getSelectedRow());
 962                     }
 963                 }
 964             });
 965         }
 966         return jButtonFvParaDel;
 967     }
 968
 969
 970
 971
 972   private JPanel getJPanelFvImageOpts() {
 973
 974
 975  if (jPanelFvImageOpts == null) {
 976      //ToDo add ButtonGroup for RadioButtons
 977             jLabelFvImageOptValue = new JLabel();
 978             jLabelFvImageOptValue.setEnabled(true);
 979             jLabelFvImageOptValue.setText("Value");
 980             jLabelFvImageOptValue.setPreferredSize(new Dimension(38, 20));
 981             jLabelFvImageOptName = new JLabel();
 982             jLabelFvImageOptName.setEnabled(true);
 983             jLabelFvImageOptName.setText("Name");
 984             jLabelFvImageOptName.setPreferredSize(new Dimension(38, 20));
 985             jPanelFvImageOpts = new JPanel();
 986             jPanelFvImageOpts.setPreferredSize(new java.awt.Dimension(480,150));
 987
 988             jPanelFvImageOpts.setLayout(new FlowLayout());
 989
 990                         jPanelFvImageOpts.setBorder(javax.swing.BorderFactory.createEtchedBorder(javax.swing.border.EtchedBorder.LOWERED));
 991                         jPanelFvImageOpts.add(getJCheckBoxFvImageOpts(), null);
 992                         jPanelFvImageOpts.add(jLabelFvImageOptName, null);
 993                         jPanelFvImageOpts.add(getJTextFieldFvImageOptName(), null);
 994                         jPanelFvImageOpts.add(jLabelFvImageOptValue, null);
 995                         jPanelFvImageOpts.add(getJTextFieldFvImageOptValue(), null);
 996                         jPanelFvImageOpts.add(getJScrollPane(), null);
 997                         jPanelFvImageOpts.add(getJPanelFvImageOptsButtonGroup(), null);
 998                         jPanelFvImageOpts.add(getJButtonAddFvImage(), null);
 999                         jPanelFvImageOpts.add(getJButtonDelFvImage(), null);
1000                         jPanelFvImageOpts.add(getJButtonUpdateFvImage(), null);
1001
1002
1003
1004
1005
1006         }
1007         return jPanelFvImageOpts;
1008     }
1009
1010
1011     /**
1012      * This method initializes jButton4
1013      *
1014      * @return javax.swing.JButton
1015      */
1016     private JButton getJButtonAddFvImage() {
1017         if (jButtonAddFvImage == null) {
1018             jButtonAddFvImage = new JButton();
1019             jButtonAddFvImage.setPreferredSize(new java.awt.Dimension(120,20));
1020 //            jButton4.setEnabled(false);
1021             jButtonAddFvImage.setText("Add FV Image");
1022             jButtonAddFvImage.addActionListener(new AbstractAction() {
1023                 /**
1024                  *
1025                  */
1026                 private static final long serialVersionUID = 1L;
1027
1028                 public void actionPerformed(java.awt.event.ActionEvent e) {
1029                     if (jTableFvInfo.isEditing()) {
1030                         jTableFvInfo.getCellEditor().stopCellEditing();
1031                     }
1032                     if (jTableFvImageOpts.isEditing()) {
1033                         jTableFvImageOpts.getCellEditor().stopCellEditing();
1034                     }
1035                     if (jTableFvImageNames.getRowCount()== 0){
1036                         return;
1037                     }
1038                     String imageName = " ";
1039                     for (int i = 0; i < jTableFvImageNames.getRowCount(); ++i){
1040                         imageName += (String)jTableFvImageNames.getValueAt(i, 0);
1041                         imageName += " ";
1042                     }
1043                     imageName = imageName.trim();
1044
1045                     if (!jCheckBoxFvImageOpts.isSelected() && jComboBoxFvParaType.getSelectedIndex() != 0){
1046                         return;
1047
1048                     }
1049
1050                     LinkedHashMap<String, String> m = null;
1051                     if (jCheckBoxFvImageOpts.isSelected()) {
1052                         m = new LinkedHashMap<String, String>();
1053                         getOptionNameValue(m);
1054                     }
1055                     ffc.genFvImagesFvImage(imageName.split(" "), jComboBoxFvParaType.getSelectedItem()+"", m);
1056                     docConsole.setSaved(false);
1057                     Object[] row = {imageName, jComboBoxFvParaType.getSelectedItem()};
1058                     fvImageParaTableModel.addRow(row);
1059                 }
1060             });
1061         }
1062         return jButtonAddFvImage;
1063     }
1064
1065
1066     /**
1067      * This method initializes jScrollPane3
1068      *
1069      * @return javax.swing.JScrollPane
1070      */
1071     private JScrollPane getJScrollPaneFvInfo() {
1072         if (jScrollPaneFvInfo == null) {
1073             jScrollPaneFvInfo = new JScrollPane();
1074             jScrollPaneFvInfo.setPreferredSize(new java.awt.Dimension(480,150));
1075             jScrollPaneFvInfo.setViewportView(getJTableFvInfo());
1076         }
1077         return jScrollPaneFvInfo;
1078     }
1079
1080
1081     /**
1082      * This method initializes jTable2
1083      *
1084      * @return javax.swing.JTable
1085      */
1086     private JTable getJTableFvInfo() {
1087         if (jTableFvInfo == null) {
1088             fvImageParaTableModel = new ImageParaTableModel();
1089             jTableFvInfo = new JTable(fvImageParaTableModel);
1090             fvImageParaTableModel.addColumn("FvImageNames");
1091             fvImageParaTableModel.addColumn("Type");
1092
1093
1094             TableColumn typeCol = jTableFvInfo.getColumnModel().getColumn(1);
1095             JComboBox cb = new JComboBox();
1096             cb.addItem("ValidImageNames");
1097             cb.addItem("Attributes");
1098             cb.addItem("Options");
1099             cb.addItem("Components");
1100             typeCol.setCellEditor(new DefaultCellEditor(cb));
1101
1102             jTableFvInfo.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1103             jTableFvInfo.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
1104                 public void valueChanged(ListSelectionEvent e) {
1105                     if (e.getValueIsAdjusting()){
1106                         return;
1107                     }
1108                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
1109                     if (lsm.isSelectionEmpty()) {
1110                         return;
1111                     }
1112                     else{
1113                         int selectedRow = lsm.getMinSelectionIndex();
1114                         LinkedHashMap<String, String> optionMap = new LinkedHashMap<String, String>();
1115                         ffc.getFvImagesFvImageOptions(selectedRow, optionMap);
1116                         if (optionMap.size() > 0){
1117                             fvOptionTableModel.setRowCount(0);
1118                             Set<String> key = optionMap.keySet();
1119                             Iterator<String> i = key.iterator();
1120                             while (i.hasNext()) {
1121
1122                                 String k = (String)i.next();
1123                                 String[] row = {k, optionMap.get(k)};
1124
1125                                 fvOptionTableModel.addRow(row);
1126                             }
1127                         }
1128
1129                     }
1130                 }
1131             });
1132
1133
1134         }
1135         return jTableFvInfo;
1136     }
1137
1138
1139     /**
1140      * This method initializes jButton6
1141      *
1142      * @return javax.swing.JButton
1143      */
1144     private JButton getJButtonDelFvImage() {
1145         if (jButtonDelFvImage == null) {
1146             jButtonDelFvImage = new JButton();
1147             jButtonDelFvImage.setPreferredSize(new java.awt.Dimension(120,20));
1148 //            jButton6.setEnabled(false);
1149             jButtonDelFvImage.setText("Delete Row");
1150             jButtonDelFvImage.addActionListener(new AbstractAction() {
1151                 /**
1152                  *
1153                  */
1154                 private static final long serialVersionUID = 1L;
1155
1156                 public void actionPerformed(ActionEvent arg0) {
1157                     // TODO Auto-generated method stub
1158                     if (jTableFvInfo.getSelectedRow() >= 0 ) {
1159                         ffc.removeFvImagesFvImage(jTableFvInfo.getSelectedRow());
1160                         fvImageParaTableModel.removeRow(jTableFvInfo.getSelectedRow());
1161                         docConsole.setSaved(false);
1162                     }
1163                 }
1164
1165             });
1166         }
1167         return jButtonDelFvImage;
1168     }
1169
1170
1171     /**
1172      * This method initializes jCheckBox3
1173      *
1174      * @return javax.swing.JCheckBox
1175      */
1176     private JCheckBox getJCheckBoxFvImageOpts() {
1177         if (jCheckBoxFvImageOpts == null) {
1178             jCheckBoxFvImageOpts = new JCheckBox();
1179             jCheckBoxFvImageOpts.setText("FV Image Options");
1180             jCheckBoxFvImageOpts.addItemListener(new ItemListener(){
1181
1182                 public void itemStateChanged(ItemEvent arg0) {
1183                     // TODO Auto-generated method stub
1184 //                    boolean selected = jCheckBox3.isSelected();
1185
1186                         if (!jCheckBoxFvImagePara.isSelected() || jComboBoxFvParaType.getSelectedIndex() == 0) {
1187                             return;
1188                         }
1189
1190 //                        jLabel5.setEnabled(selected);
1191 //                        jTextField4.setEnabled(selected);
1192 //                        jLabel6.setEnabled(selected);
1193 //                        jTextField5.setEnabled(selected);
1194 //                        jButton7.setEnabled(selected);
1195 //                        jButton8.setEnabled(selected);
1196
1197                 }
1198
1199             });
1200         }
1201         return jCheckBoxFvImageOpts;
1202     }
1203
1204
1205     /**
1206      * This method initializes jPanel6
1207      *
1208      * @return javax.swing.JPanel
1209      */
1210     private JPanel getJPanelFvImagePara() {
1211         if (jPanelFvImagePara == null) {
1212             StarLabel starLabel = new StarLabel();
1213             starLabel.setVisible(false);
1214             jPanelFvImagePara = new JPanel();
1215             jPanelFvImagePara.setPreferredSize(new java.awt.Dimension(480,120));
1216             jPanelFvImagePara.setBorder(javax.swing.BorderFactory.createEtchedBorder(javax.swing.border.EtchedBorder.RAISED));
1217             jPanelFvImagePara.add(getJCheckBoxFvImagePara(), null);
1218             jPanelFvImagePara.add(jLabelFvParaType, null);
1219             jPanelFvImagePara.add(getJComboBoxFvParaType(), null);
1220             jPanelFvImagePara.add(new StarLabel(), null);
1221             jPanelFvImagePara.add(jLabelFvImageNames, null);
1222             jPanelFvImagePara.add(jLabelFvParaName, null);
1223             jPanelFvImagePara.add(getJTextFieldFvParaName(), null);
1224             jPanelFvImagePara.add(getJButtonFvParaAdd(), null);
1225             jPanelFvImagePara.add(getJScrollPaneFvImageNames(), null);
1226             jPanelFvImagePara.add(getJButtonFvParaDel(), null);
1227         }
1228         return jPanelFvImagePara;
1229     }
1230
1231     /**
1232      * This method initializes jPanel7
1233      *
1234      * @return javax.swing.JPanel
1235      */
1236     private JPanel getJPanelFdf() {
1237         if (jPanelFdf == null) {
1238             jPanelFdf = new JPanel();
1239             jPanelFdf.setLayout(new BorderLayout());
1240
1241             jPanelFdf.add(getJPanelFdfN(), java.awt.BorderLayout.NORTH);
1242             jPanelFdf.add(getJPanelFdfS(), java.awt.BorderLayout.SOUTH);
1243             jPanelFdf.add(getJSplitPaneFdfC(), java.awt.BorderLayout.CENTER);
1244 //            jPanelFdf.addComponentListener(new ComponentAdapter(){
1245 //                public void componentShown(ComponentEvent e) {
1246 //                    if (ffc.getFlashDefinitionFile() != null) {
1247 //                        jTextFieldFdf.setText(ffc.getFlashDefinitionFile());
1248 //                    }
1249 //                }
1250 //                public void componentHidden(ComponentEvent e) {
1251 //                    if (jCheckBoxFdf.isSelected()) {
1252 //                        ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1253 //                    }
1254 //                }
1255 //            });
1256         }
1257         return jPanelFdf;
1258     }
1259
1260     /**
1261      * This method initializes jCheckBox
1262      *
1263      * @return javax.swing.JCheckBox
1264      */
1265     private JCheckBox getJCheckBoxFdf() {
1266         if (jCheckBoxFdf == null) {
1267             jCheckBoxFdf = new JCheckBox();
1268             jCheckBoxFdf.setText("Flash Definition File");
1269             jCheckBoxFdf.addItemListener(new ItemListener() {
1270
1271                 public void itemStateChanged(ItemEvent arg0) {
1272                     // TODO Auto-generated method stub
1273                     if (jCheckBoxFdf.isSelected()){
1274                         jTextFieldFdf.setEnabled(true);
1275                         jButtonFdfBrowse.setEnabled(true);
1276                     }
1277                     else {
1278
1279                         jTextFieldFdf.setEnabled(false);
1280                         jButtonFdfBrowse.setEnabled(false);
1281                     }
1282                 }
1283             });
1284         }
1285         return jCheckBoxFdf;
1286     }
1287
1288     /**
1289      * This method initializes jTextField3
1290      *
1291      * @return javax.swing.JTextField
1292      */
1293     private JTextField getJTextFieldFdf() {
1294         if (jTextFieldFdf == null) {
1295             jTextFieldFdf = new JTextField();
1296             jTextFieldFdf.setEnabled(false);
1297             jTextFieldFdf.setPreferredSize(new Dimension(300, 20));
1298             jTextFieldFdf.addFocusListener(new java.awt.event.FocusAdapter() {
1299                 public void focusLost(java.awt.event.FocusEvent e) {
1300                     ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1301                 }
1302             });
1303         }
1304         return jTextFieldFdf;
1305     }
1306
1307     /**
1308      * This method initializes jButton5
1309      *
1310      * @return javax.swing.JButton
1311      */
1312     private JButton getJButtonFdfBrowse() {
1313         if (jButtonFdfBrowse == null) {
1314             jButtonFdfBrowse = new JButton();
1315             jButtonFdfBrowse.setEnabled(false);
1316             jButtonFdfBrowse.setText("Browse");
1317             jButtonFdfBrowse.setPreferredSize(new Dimension(78, 20));
1318             jButtonFdfBrowse.addActionListener(new AbstractAction(){
1319                 /**
1320                  *
1321                  */
1322                 private static final long serialVersionUID = 1L;
1323
1324                 public void actionPerformed(ActionEvent e) {
1325                     // TODO Auto-generated method stub
1326                     String wsDir = System.getenv("WORKSPACE");
1327                     JFileChooser chooser = new JFileChooser(wsDir);
1328                     chooser.setMultiSelectionEnabled(false);
1329                     chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
1330                     int retval = chooser.showOpenDialog(frame);
1331                     if (retval == JFileChooser.APPROVE_OPTION) {
1332
1333                         File theFile = chooser.getSelectedFile();
1334                         String filePath = theFile.getPath();
1335                         if (!filePath.startsWith(wsDir)) {
1336                             JOptionPane.showMessageDialog(frame, "You can only select files in current WORKSPACE.");
1337                             return;
1338                         }
1339                         jTextFieldFdf.setText(filePath.substring(wsDir.length() + 1).replace('\\', '/'));
1340                         ffc.genFlashDefinitionFile(jTextFieldFdf.getText());
1341                         docConsole.setSaved(false);
1342                         Vector<FvInfoFromFdf> vFvInfo = new Vector<FvInfoFromFdf>();
1343                         getFvInfoFromFdf(filePath, vFvInfo);
1344                         getFvInFdfTableModel().setRowCount(0);
1345                         for (int j = 0; j < vFvInfo.size(); ++j) {
1346                             FvInfoFromFdf fvInfo = vFvInfo.get(j);
1347                             String[] row = {fvInfo.getFvName(), fvInfo.getSize(), fvInfo.getEfiFileName()};
1348                             getFvInFdfTableModel().addRow(row);
1349                         }
1350                     }
1351                 }
1352
1353             });
1354         }
1355         return jButtonFdfBrowse;
1356     }
1357
1358     /**
1359      * This method initializes jTextField4
1360      *
1361      * @return javax.swing.JTextField
1362      */
1363     private JTextField getJTextFieldFvImageOptName() {
1364         if (jTextFieldFvImageOptName == null) {
1365             jTextFieldFvImageOptName = new JTextField();
1366             jTextFieldFvImageOptName.setEnabled(true);
1367             jTextFieldFvImageOptName.setPreferredSize(new Dimension(100, 20));
1368         }
1369         return jTextFieldFvImageOptName;
1370     }
1371
1372     /**
1373      * This method initializes jTextField5
1374      *
1375      * @return javax.swing.JTextField
1376      */
1377     private JTextField getJTextFieldFvImageOptValue() {
1378         if (jTextFieldFvImageOptValue == null) {
1379             jTextFieldFvImageOptValue = new JTextField();
1380             jTextFieldFvImageOptValue.setEnabled(true);
1381             jTextFieldFvImageOptValue.setPreferredSize(new Dimension(100, 20));
1382         }
1383         return jTextFieldFvImageOptValue;
1384     }
1385
1386     /**
1387      * This method initializes jPanel8
1388      *
1389      * @return javax.swing.JPanel
1390      */
1391     private JPanel getJPanelFvImageOptsButtonGroup() {
1392         if (jPanelFvImageOptsButtonGroup == null) {
1393             jPanelFvImageOptsButtonGroup = new JPanel();
1394             jPanelFvImageOptsButtonGroup.setPreferredSize(new Dimension(80, 55));
1395             jPanelFvImageOptsButtonGroup.add(getJButtonFvImageOptAdd(), null);
1396             jPanelFvImageOptsButtonGroup.add(getJButtonFvImageOptDel(), null);
1397         }
1398         return jPanelFvImageOptsButtonGroup;
1399     }
1400
1401     /**
1402      * This method initializes jButton7
1403      *
1404      * @return javax.swing.JButton
1405      */
1406     private JButton getJButtonFvImageOptAdd() {
1407         if (jButtonFvImageOptAdd == null) {
1408             jButtonFvImageOptAdd = new JButton();
1409             jButtonFvImageOptAdd.setEnabled(true);
1410             jButtonFvImageOptAdd.setText("Add");
1411             jButtonFvImageOptAdd.setPreferredSize(new Dimension(80, 20));
1412             jButtonFvImageOptAdd.addActionListener(new AbstractAction() {
1413                 /**
1414                  *
1415                  */
1416                 private static final long serialVersionUID = 1L;
1417
1418                 public void actionPerformed(ActionEvent e) {
1419                     if (jTextFieldFvImageOptName.getText().length() > 0 && jTextFieldFvImageOptValue.getText().length() > 0){
1420                         String[] row = {jTextFieldFvImageOptName.getText(), jTextFieldFvImageOptValue.getText()};
1421                         fvOptionTableModel.addRow(row);
1422                     }
1423                 }
1424             });
1425         }
1426         return jButtonFvImageOptAdd;
1427     }
1428
1429     /**
1430      * This method initializes jButton8
1431      *
1432      * @return javax.swing.JButton
1433      */
1434     private JButton getJButtonFvImageOptDel() {
1435         if (jButtonFvImageOptDel == null) {
1436             jButtonFvImageOptDel = new JButton();
1437             jButtonFvImageOptDel.setEnabled(true);
1438             jButtonFvImageOptDel.setText("Delete");
1439             jButtonFvImageOptDel.setPreferredSize(new Dimension(80, 20));
1440             jButtonFvImageOptDel.addActionListener(new AbstractAction() {
1441                 /**
1442                  *
1443                  */
1444                 private static final long serialVersionUID = 1L;
1445
1446                 public void actionPerformed(ActionEvent e) {
1447                     if (jTableFvImageOpts.getSelectedRow() >= 0){
1448                         fvOptionTableModel.removeRow(jTableFvProp.getSelectedRow());
1449                     }
1450                 }
1451             });
1452         }
1453         return jButtonFvImageOptDel;
1454     }
1455
1456     /**
1457      * This method initializes jScrollPane
1458      *
1459      * @return javax.swing.JScrollPane
1460      */
1461     private JScrollPane getJScrollPane() {
1462         if (jScrollPane == null) {
1463             jScrollPane = new JScrollPane();
1464             jScrollPane.setPreferredSize(new java.awt.Dimension(350,80));
1465             jScrollPane.setViewportView(getJTableFvImageOpts());
1466         }
1467         return jScrollPane;
1468     }
1469
1470     /**
1471      * This method initializes jTable3
1472      *
1473      * @return javax.swing.JTable
1474      */
1475     private JTable getJTableFvImageOpts() {
1476         if (jTableFvImageOpts == null) {
1477             fvOptionTableModel = new DefaultTableModel();
1478             fvOptionTableModel.addColumn("Name");
1479             fvOptionTableModel.addColumn("Value");
1480             jTableFvImageOpts = new JTable(fvOptionTableModel);
1481
1482             jTableFvImageOpts.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1483             jTableFvImageOpts.setRowHeight(20);
1484
1485         }
1486         return jTableFvImageOpts;
1487     }
1488
1489     /**
1490      * This method initializes jButton9
1491      *
1492      * @return javax.swing.JButton
1493      */
1494     private JButton getJButtonUpdateFvImage() {
1495         if (jButtonUpdateFvImage == null) {
1496             jButtonUpdateFvImage = new JButton();
1497             jButtonUpdateFvImage.setPreferredSize(new Dimension(120, 20));
1498             jButtonUpdateFvImage.setActionCommand("Update");
1499             jButtonUpdateFvImage.setText("Update FV");
1500             jButtonUpdateFvImage.addActionListener(new java.awt.event.ActionListener() {
1501                 public void actionPerformed(java.awt.event.ActionEvent e) {
1502                     int row = jTableFvInfo.getSelectedRow();
1503                     if (jTableFvInfo.isEditing()) {
1504                         jTableFvInfo.getCellEditor().stopCellEditing();
1505                     }
1506                     if (jTableFvImageOpts.isEditing()) {
1507                         jTableFvImageOpts.getCellEditor().stopCellEditing();
1508                     }
1509
1510                         //ToDo Check data validity before update
1511                         String name = fvImageParaTableModel.getValueAt(row, 0) + "";
1512                         String type = fvImageParaTableModel.getValueAt(row, 1) + "";
1513
1514                         LinkedHashMap<String, String> lhm = new LinkedHashMap<String, String>();
1515                         getOptionNameValue(lhm);
1516
1517                         docConsole.setSaved(false);
1518                         ffc.updateFvImagesFvImage(row, name.split(" "), type, lhm);
1519
1520                 }
1521             });
1522         }
1523         return jButtonUpdateFvImage;
1524     }
1525
1526     /**
1527      * This method initializes jButtonTest
1528      *
1529      * @return javax.swing.JButton
1530      */
1531 //    private JButton getJButtonTest() {
1532 //        if (jButtonTest == null) {
1533 //            jButtonTest = new JButton();
1534 //            jButtonTest.addActionListener(new java.awt.event.ActionListener() {
1535 //                public void actionPerformed(java.awt.event.ActionEvent e) {
1536 //                    docConsole.setSaved(false);
1537 //                    String[][] includeModules = {{"1", "a"}, {"2", "b"}};
1538 //                    ffc.genBuildOptionsUserExtensions("FV_RECOVERY", "FvRecovery.inf", null, includeModules);
1539 //                    int i = ffc.getUserExtsIncModCount("FV_RECOVERY");
1540 //                    String[][] saa = new String[i][2];
1541 //                    ffc.getUserExtsIncMods("FV_RECOVERY", saa);
1542 //                    jTextFieldFdf.setText(saa[0][0] + saa[0][1] + saa[1][0] + saa[1][1]);
1543 //
1544 //                }
1545 //            });
1546 //        }
1547 //        return jButtonTest;
1548 //    }
1549
1550     /**
1551      * This method initializes jPanelFdfN
1552      *
1553      * @return javax.swing.JPanel
1554      */
1555     private JPanel getJPanelFdfN() {
1556         if (jPanelFdfN == null) {
1557             jPanelFdfN = new JPanel();
1558             jPanelFdfN.add(getJCheckBoxFdf(), null);
1559             jPanelFdfN.add(getJTextFieldFdf(), null);
1560             jPanelFdfN.add(getJButtonFdfBrowse(), null);
1561         }
1562         return jPanelFdfN;
1563     }
1564
1565     /**
1566      * This method initializes jPanelFdfS
1567      *
1568      * @return javax.swing.JPanel
1569      */
1570     private JPanel getJPanelFdfS() {
1571         if (jPanelFdfS == null) {
1572             FlowLayout flowLayout4 = new FlowLayout();
1573             flowLayout4.setAlignment(java.awt.FlowLayout.RIGHT);
1574             jPanelFdfS = new JPanel();
1575             jPanelFdfS.setLayout(flowLayout4);
1576             jPanelFdfS.add(getJButtonAddFv(), null);
1577             jPanelFdfS.add(getJButtonDelFv(), null);
1578             jPanelFdfS.add(getJButtonAddFvOptions(), null);
1579         }
1580         return jPanelFdfS;
1581     }
1582
1583     /**
1584      * This method initializes jSplitPaneFdfC
1585      *
1586      * @return javax.swing.JSplitPane
1587      */
1588     private JSplitPane getJSplitPaneFdfC() {
1589         if (jSplitPaneFdfC == null) {
1590             jSplitPaneFdfC = new JSplitPane();
1591             jSplitPaneFdfC.setOrientation(javax.swing.JSplitPane.VERTICAL_SPLIT);
1592             jSplitPaneFdfC.setDividerSize(5);
1593             jSplitPaneFdfC.setTopComponent(getJPanelFdfCTop());
1594             jSplitPaneFdfC.setBottomComponent(getJPanelFdfCBottom());
1595             jSplitPaneFdfC.setDividerLocation(280);
1596         }
1597         return jSplitPaneFdfC;
1598     }
1599
1600     /**
1601      * This method initializes jPanelFdfCTop
1602      *
1603      * @return javax.swing.JPanel
1604      */
1605     private JPanel getJPanelFdfCTop() {
1606         if (jPanelFdfCTop == null) {
1607             jPanelFdfCTop = new JPanel();
1608             jPanelFdfCTop.setLayout(new BorderLayout());
1609             jPanelFdfCTop.add(getJPanelFdfCTopN(), java.awt.BorderLayout.NORTH);
1610             jPanelFdfCTop.add(getJPanelFdfCTopS(), java.awt.BorderLayout.SOUTH);
1611             jPanelFdfCTop.add(getJPanelFdfCTopC(), java.awt.BorderLayout.CENTER);
1612         }
1613         return jPanelFdfCTop;
1614     }
1615
1616     /**
1617      * This method initializes jPanelFdfCBottom
1618      *
1619      * @return javax.swing.JPanel
1620      */
1621     private JPanel getJPanelFdfCBottom() {
1622         if (jPanelFdfCBottom == null) {
1623             jPanelFdfCBottom = new JPanel();
1624             jPanelFdfCBottom.setLayout(new BorderLayout());
1625             jPanelFdfCBottom.add(getJPanelFdfCBottomN(), java.awt.BorderLayout.NORTH);
1626             jPanelFdfCBottom.add(getJPanelFdfCBottomC(), java.awt.BorderLayout.CENTER);
1627         }
1628         return jPanelFdfCBottom;
1629     }
1630
1631     /**
1632      * This method initializes jPanelFdfCTopN
1633      *
1634      * @return javax.swing.JPanel
1635      */
1636     private JPanel getJPanelFdfCTopN() {
1637         if (jPanelFdfCTopN == null) {
1638             jLabelFvInFdf = new JLabel();
1639             jLabelFvInFdf.setText("FVs in Flash Definition File");
1640             jPanelFdfCTopN = new JPanel();
1641             jPanelFdfCTopN.add(jLabelFvInFdf, null);
1642         }
1643         return jPanelFdfCTopN;
1644     }
1645
1646     /**
1647      * This method initializes jPanelFdfCTopS
1648      *
1649      * @return javax.swing.JPanel
1650      */
1651     private JPanel getJPanelFdfCTopS() {
1652         if (jPanelFdfCTopS == null) {
1653             FlowLayout flowLayout1 = new FlowLayout();
1654             flowLayout1.setAlignment(java.awt.FlowLayout.RIGHT);
1655             jPanelFdfCTopS = new JPanel();
1656             jPanelFdfCTopS.setLayout(flowLayout1);
1657             jPanelFdfCTopS.add(getJButtonFvInFdfOptions(), null);
1658         }
1659         return jPanelFdfCTopS;
1660     }
1661
1662     /**
1663      * This method initializes jPanelFdfCTopC
1664      *
1665      * @return javax.swing.JPanel
1666      */
1667     private JPanel getJPanelFdfCTopC() {
1668         if (jPanelFdfCTopC == null) {
1669             jPanelFdfCTopC = new JPanel();
1670             jPanelFdfCTopC.add(getJScrollPaneFvInFdf(), null);
1671         }
1672         return jPanelFdfCTopC;
1673     }
1674
1675     /**
1676      * This method initializes jPanelFdfCBottomN
1677      *
1678      * @return javax.swing.JPanel
1679      */
1680     private JPanel getJPanelFdfCBottomN() {
1681         if (jPanelFdfCBottomN == null) {
1682             jLabelFvAdditional = new JLabel();
1683             jLabelFvAdditional.setText("Additional FVs");
1684             jPanelFdfCBottomN = new JPanel();
1685             jPanelFdfCBottomN.add(jLabelFvAdditional, null);
1686         }
1687         return jPanelFdfCBottomN;
1688     }
1689
1690     /**
1691      * This method initializes jPanelFdfCBottomC
1692      *
1693      * @return javax.swing.JPanel
1694      */
1695     private JPanel getJPanelFdfCBottomC() {
1696         if (jPanelFdfCBottomC == null) {
1697             jPanelFdfCBottomC = new JPanel();
1698             jPanelFdfCBottomC.add(getJScrollPaneFvAdditional(), null);
1699         }
1700         return jPanelFdfCBottomC;
1701     }
1702
1703     /**
1704      * This method initializes jScrollPaneFvInFdf
1705      *
1706      * @return javax.swing.JScrollPane
1707      */
1708     private JScrollPane getJScrollPaneFvInFdf() {
1709         if (jScrollPaneFvInFdf == null) {
1710             jScrollPaneFvInFdf = new JScrollPane();
1711             jScrollPaneFvInFdf.setPreferredSize(new java.awt.Dimension(653,200));
1712             jScrollPaneFvInFdf.setViewportView(getJTableFvInFdf());
1713         }
1714         return jScrollPaneFvInFdf;
1715     }
1716
1717     /**
1718      * This method initializes jTableFvInFdf
1719      *
1720      * @return javax.swing.JTable
1721      */
1722     private JTable getJTableFvInFdf() {
1723         if (jTableFvInFdf == null) {
1724             jTableFvInFdf = new JTable();
1725             jTableFvInFdf.setRowHeight(20);
1726             jTableFvInFdf.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
1727             jTableFvInFdf.setModel(getFvInFdfTableModel());
1728         }
1729         return jTableFvInFdf;
1730     }
1731
1732     /**
1733      * This method initializes fvInFdfTableModel
1734      *
1735      * @return org.tianocore.frameworkwizard.platform.ui.NonEditableTableModel
1736      */
1737     private NonEditableTableModel getFvInFdfTableModel() {
1738         if (fvInFdfTableModel == null) {
1739             fvInFdfTableModel = new NonEditableTableModel();
1740             fvInFdfTableModel.addColumn("FV Name");
1741             fvInFdfTableModel.addColumn("Size");
1742             fvInFdfTableModel.addColumn("Corresponding File Name");
1743         }
1744         return fvInFdfTableModel;
1745     }
1746
1747     /**
1748      * This method initializes jButtonFvInFdfOptions
1749      *
1750      * @return javax.swing.JButton
1751      */
1752     private JButton getJButtonFvInFdfOptions() {
1753         if (jButtonFvInFdfOptions == null) {
1754             jButtonFvInFdfOptions = new JButton();
1755             jButtonFvInFdfOptions.setPreferredSize(new java.awt.Dimension(80,20));
1756             jButtonFvInFdfOptions.setText("Options");
1757             jButtonFvInFdfOptions.addActionListener(new java.awt.event.ActionListener() {
1758                 public void actionPerformed(java.awt.event.ActionEvent e) {
1759                     int selectedRow = jTableFvInFdf.getSelectedRow();
1760                     if (selectedRow <= 0) {
1761                         return;
1762                     }
1763                     fvInFdfTableModel.moveRow(selectedRow, selectedRow, selectedRow - 1);
1764                     jTableFvInFdf.changeSelection(selectedRow - 1, 0, false, false);
1765                 }
1766             });
1767         }
1768         return jButtonFvInFdfOptions;
1769     }
1770
1771     /**
1772      * This method initializes jScrollPaneFvAdditional
1773      *
1774      * @return javax.swing.JScrollPane
1775      */
1776     private JScrollPane getJScrollPaneFvAdditional() {
1777         if (jScrollPaneFvAdditional == null) {
1778             jScrollPaneFvAdditional = new JScrollPane();
1779             jScrollPaneFvAdditional.setPreferredSize(new java.awt.Dimension(653,200));
1780             jScrollPaneFvAdditional.setViewportView(getJTableFvAdditional());
1781         }
1782         return jScrollPaneFvAdditional;
1783     }
1784
1785     /**
1786      * This method initializes jTableFvAdditional
1787      *
1788      * @return javax.swing.JTable
1789      */
1790     private JTable getJTableFvAdditional() {
1791         if (jTableFvAdditional == null) {
1792             jTableFvAdditional = new JTable();
1793             jTableFvAdditional.setRowHeight(20);
1794             jTableFvAdditional.setSelectionMode(javax.swing.ListSelectionModel.SINGLE_SELECTION);
1795             jTableFvAdditional.setModel(getFvAddtionalTableModel());
1796         }
1797         return jTableFvAdditional;
1798     }
1799
1800     /**
1801      * This method initializes fvAddtionalTableModel
1802      *
1803      * @return javax.swing.table.DefaultTableModel
1804      */
1805     private DefaultTableModel getFvAddtionalTableModel() {
1806         if (fvAddtionalTableModel == null) {
1807             fvAddtionalTableModel = new DefaultTableModel();
1808             fvAddtionalTableModel.addColumn("FV Name");
1809             fvAddtionalTableModel.addColumn("Size");
1810             fvAddtionalTableModel.addColumn("Corresponding File Name");
1811         }
1812         return fvAddtionalTableModel;
1813     }
1814
1815     /**
1816      * This method initializes jButtonAddFv
1817      *
1818      * @return javax.swing.JButton
1819      */
1820     private JButton getJButtonAddFv() {
1821         if (jButtonAddFv == null) {
1822             jButtonAddFv = new JButton();
1823             jButtonAddFv.setPreferredSize(new java.awt.Dimension(80,20));
1824             jButtonAddFv.setText("New");
1825         }
1826         return jButtonAddFv;
1827     }
1828
1829     /**
1830      * This method initializes jButtonDelFv
1831      *
1832      * @return javax.swing.JButton
1833      */
1834     private JButton getJButtonDelFv() {
1835         if (jButtonDelFv == null) {
1836             jButtonDelFv = new JButton();
1837             jButtonDelFv.setPreferredSize(new java.awt.Dimension(80,20));
1838             jButtonDelFv.setText("Delete");
1839         }
1840         return jButtonDelFv;
1841     }
1842
1843     /**
1844      * This method initializes jButtonAddFvOptions
1845      *
1846      * @return javax.swing.JButton
1847      */
1848     private JButton getJButtonAddFvOptions() {
1849         if (jButtonAddFvOptions == null) {
1850             jButtonAddFvOptions = new JButton();
1851             jButtonAddFvOptions.setPreferredSize(new java.awt.Dimension(80,20));
1852             jButtonAddFvOptions.setText("Options");
1853         }
1854         return jButtonAddFvOptions;
1855     }
1856
1857
1858
1859     /**
1860      * This method initializes nonEditableTableModel
1861      *
1862      * @return org.tianocore.frameworkwizard.platform.ui.NonEditableTableModel
1863      */
1864     private NonEditableTableModel getNonEditableTableModel() {
1865         if (nonEditableTableModel == null) {
1866             nonEditableTableModel = new NonEditableTableModel();
1867         }
1868         return nonEditableTableModel;
1869     }
1870
1871
1872     /**
1873      * @param args
1874      */
1875     public static void main(String[] args) {
1876         // TODO Auto-generated method stub
1877         new FpdFlash().setVisible(true);
1878     }
1879
1880     /**
1881      * This method initializes this
1882      *
1883      * @return void
1884      */
1885     private void initialize() {
1886         this.setSize(518, 650);
1887         this.setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
1888         this.setContentPane(getJContentPane());
1889         this.setTitle("FPD Flash Definitions");
1890         this.addInternalFrameListener(new InternalFrameAdapter(){
1891             public void internalFrameDeactivated(InternalFrameEvent e){
1892                 if (jTableFvProp.isEditing()) {
1893                     jTableFvProp.getCellEditor().stopCellEditing();
1894                 }
1895                 if (jTableFvImageNames.isEditing()) {
1896                     jTableFvImageNames.getCellEditor().stopCellEditing();
1897                 }
1898                 if (jTableFvInfo.isEditing()) {
1899                     jTableFvInfo.getCellEditor().stopCellEditing();
1900                 }
1901             }
1902         });
1903     }
1904
1905     private void init(FpdFileContents ffc) {
1906         if (ffc.getFvImagesFvImageCount() == 0) {
1907             return;
1908         }
1909         String[][] saa = new String[ffc.getFvImagesFvImageCount()][2];
1910         ffc.getFvImagesFvImages(saa);
1911
1912         int i = 0;
1913         while (i < saa.length) {
1914
1915             fvImageParaTableModel.addRow(saa[i]);
1916             ++i;
1917         }
1918
1919         saa = new String[ffc.getFvImagesNameValueCount()][2];
1920         ffc.getFvImagesNameValues(saa);
1921         for (int m = 0; m < saa.length; ++m) {
1922             fvPropertyTableModel.addRow(saa[m]);
1923         }
1924
1925         jTextFieldFdf.setText("");
1926         String fdfFile = ffc.getFlashDefinitionFile();
1927         if (fdfFile != null) {
1928             jTextFieldFdf.setText(fdfFile);
1929         }
1930
1931         String fdfPath = System.getenv("WORKSPACE") + File.separator + fdfFile;
1932         Vector<FvInfoFromFdf> vFvInfo = new Vector<FvInfoFromFdf>();
1933         getFvInfoFromFdf(fdfPath, vFvInfo);
1934         getFvInFdfTableModel().setRowCount(0);
1935         for (int j = 0; j < vFvInfo.size(); ++j) {
1936             FvInfoFromFdf fvInfo = vFvInfo.get(j);
1937             String[] row = {fvInfo.getFvName(), fvInfo.getSize(), fvInfo.getEfiFileName()};
1938             getFvInFdfTableModel().addRow(row);
1939         }
1940
1941
1942         for (int k = 0; k < vFvInfo.size(); ++k) {
1943             FvInfoFromFdf fvInfo = vFvInfo.get(k);
1944             getJTabbedPane().addTab(fvInfo.getFvName(), null, getJPanelModOrder(), null);
1945
1946         }
1947     }
1948
1949     private void getOptionNameValue(Map<String, String> m){
1950         for (int i = 0; i < jTableFvImageOpts.getRowCount(); ++i) {
1951             m.put(fvOptionTableModel.getValueAt(i, 0)+"", fvOptionTableModel.getValueAt(i, 1)+"");
1952         }
1953     }
1954     /**
1955      * This method initializes jContentPane
1956      *
1957      * @return javax.swing.JPanel
1958      */
1959     private JPanel getJContentPane() {
1960         if (jContentPane == null) {
1961             jContentPane = new JPanel();
1962             jContentPane.setLayout(new BorderLayout());
1963             jContentPane.add(getJPanelContentEast(), java.awt.BorderLayout.EAST);
1964             jContentPane.add(getJPanelContentSouth(), java.awt.BorderLayout.SOUTH);
1965             jContentPane.add(getJPanelContentWest(), java.awt.BorderLayout.WEST);
1966             jContentPane.add(getJPanelContentNorth(), java.awt.BorderLayout.NORTH);
1967             jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
1968         }
1969         return jContentPane;
1970     }
1971
1972     private void getFvInfoFromFdf(String fdfPath, Vector<FvInfoFromFdf> vFvInfo) {
1973         File fdf = new File(fdfPath);
1974         if (!fdf.exists()) {
1975             return;
1976         }
1977         int lines = 0;
1978
1979         try {
1980             FileReader reader = new FileReader(fdf);
1981             BufferedReader in = new BufferedReader(reader);
1982             String str;
1983
1984             while ((str = in.readLine()) != null) {
1985                 ++lines;
1986                 str = str.trim();
1987                 //
1988                 // skip empty line, comment (start with //)
1989                 //
1990                 if (str.length() == 0 || str.startsWith("//")) {
1991                     continue;
1992                 }
1993                 //
1994                 // dig into Region {} section, create FvInfoFromFdf object for it.
1995                 //
1996                 if (str.startsWith("Region") && str.endsWith("{")) {
1997                     FvInfoFromFdf fvInfo = new FvInfoFromFdf();
1998                     boolean nameFound = false;
1999                     boolean sizeFound = false;
2000                     while ((str = in.readLine()) != null) {
2001                         ++lines;
2002                         str = str.trim();
2003                         //
2004                         // skip empty line, comment (start with //)
2005                         //
2006                         if (str.length() == 0 || str.startsWith("//")) {
2007                             continue;
2008                         }
2009
2010                         if (str.startsWith("Name")) {
2011                             int firstQuote = str.indexOf("\"");
2012                             int lastQuote = str.lastIndexOf("\"");
2013                             fvInfo.setFvName(str.substring(firstQuote + 1, lastQuote));
2014                             nameFound = true;
2015                         }
2016
2017                         if (str.startsWith("Size")) {
2018                             int equalIndex = str.indexOf("=");
2019                             int commaIndex = str.indexOf(",");
2020                             fvInfo.setSize(str.substring(equalIndex + 1, commaIndex).trim());
2021                             sizeFound = true;
2022                         }
2023
2024                         if (nameFound && sizeFound) {
2025                             break;
2026                         }
2027                     }
2028
2029                     vFvInfo.add(fvInfo);
2030                 }
2031                 //
2032                 // dig into File {} section, supply file name information to existing FvInfoFromFdf object.
2033                 //
2034                 if (str.startsWith("File")) {
2035                     boolean fileNameFound = false;
2036                     boolean fvFound = false;
2037                     String fileName = "";
2038                     String fvName = "";
2039                     while ((str = in.readLine()) != null) {
2040                         ++lines;
2041                         str = str.trim();
2042                         //
2043                         // skip empty line, comment (start with //)
2044                         //
2045                         if (str.length() == 0 || str.startsWith("//")) {
2046                             continue;
2047                         }
2048
2049                         if (str.startsWith("Name")) {
2050                             int firstQuote = str.indexOf("\"");
2051                             int lastQuote = str.lastIndexOf("\"");
2052                             fileName = str.substring(firstQuote + 1, lastQuote);
2053                             fileNameFound = true;
2054                         }
2055
2056                         if (str.startsWith("Region")) {
2057                             int firstQuote = str.indexOf("\"");
2058                             int lastQuote = str.lastIndexOf("\"");
2059                             fvName = str.substring(firstQuote + 1, lastQuote);
2060                             fvFound = true;
2061                         }
2062
2063                         if (fileNameFound && fvFound) {
2064                             break;
2065                         }
2066                     }
2067
2068                     for (int i = 0; i <vFvInfo.size(); ++i) {
2069                         if (vFvInfo.get(i).getFvName().equals(fvName)) {
2070                             vFvInfo.get(i).setEfiFileName(fileName);
2071                         }
2072                     }
2073                 }
2074
2075             }
2076         } catch (Exception e) {
2077
2078         }
2079
2080     }
2081
2082
2083
2084 }  //  @jve:decl-index=0:visual-constraint="10,10"
2085
2086 class ImageParaTableModel extends DefaultTableModel {
2087
2088     private static final long serialVersionUID = 1L;
2089
2090    public boolean isCellEditable(int row, int col) {
2091         if (getValueAt(row, 1).equals("ImageName") && col >=1) {
2092             return false;
2093         }
2094         return true;
2095     }
2096 }
2097
2098 class FvInfoFromFdf {
2099     private String fvName;
2100     private String size;
2101     private String efiFileName;
2102
2103     public FvInfoFromFdf () {
2104         fvName = "";
2105         size = "";
2106         efiFileName = "";
2107     }
2108     public FvInfoFromFdf (String f, String s, String e) {
2109         this();
2110         fvName = f;
2111         size = s;
2112         efiFileName = e;
2113     }
2114     public String getEfiFileName() {
2115         return efiFileName;
2116     }
2117     public void setEfiFileName(String efiFileName) {
2118         this.efiFileName = efiFileName;
2119     }
2120     public String getFvName() {
2121         return fvName;
2122     }
2123     public void setFvName(String fvName) {
2124         this.fvName = fvName;
2125     }
2126     public String getSize() {
2127         return size;
2128     }
2129     public void setSize(String size) {
2130         this.size = size;
2131     }
2132
2133 }