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

   1 package org.tianocore.frameworkwizard.platform.ui;
   2
   3 import java.awt.BorderLayout;
   4 import java.awt.Dimension;
   5 import java.awt.Toolkit;
   6
   7 import javax.swing.JFrame;
   8 import javax.swing.JOptionPane;
   9 import javax.swing.JPanel;
  10 import javax.swing.JDialog;
  11 import javax.swing.JTabbedPane;
  12 import javax.swing.JLabel;
  13 import javax.swing.JScrollPane;
  14 import javax.swing.JTable;
  15 import javax.swing.JTextArea;
  16 import javax.swing.JSplitPane;
  17 import javax.swing.JButton;
  18 import javax.swing.ListSelectionModel;
  19 import javax.swing.event.ListSelectionEvent;
  20 import javax.swing.event.ListSelectionListener;
  21 import javax.swing.event.TableModelEvent;
  22 import javax.swing.event.TableModelListener;
  23 import javax.swing.table.DefaultTableModel;
  24 import javax.swing.table.TableModel;
  25
  26 import org.apache.xmlbeans.XmlObject;
  27 import org.tianocore.frameworkwizard.common.DataValidation;
  28 import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType;
  29 import org.tianocore.frameworkwizard.platform.ui.global.GlobalData;
  30 import org.tianocore.frameworkwizard.platform.ui.global.SurfaceAreaQuery;
  31 import org.tianocore.frameworkwizard.platform.ui.id.ModuleIdentification;
  32 import org.tianocore.frameworkwizard.platform.ui.id.PackageIdentification;
  33
  34 import java.awt.FlowLayout;
  35 import java.awt.event.ActionEvent;
  36 import java.awt.event.ActionListener;
  37 import java.util.ArrayList;
  38 import java.util.HashMap;
  39 import java.util.Iterator;
  40 import java.util.ListIterator;
  41 import java.util.Map;
  42 import java.util.Set;
  43 import java.util.Vector;
  44
  45 import javax.swing.JTextField;
  46 import java.awt.GridLayout;
  47 import javax.swing.JComboBox;
  48
  49 public class FpdModuleSA extends JDialog implements ActionListener {
  50
  51     /**
  52      *
  53      */
  54     private static final long serialVersionUID = 1L;
  55     static JFrame frame;
  56     private JPanel jContentPane = null;
  57     private JTabbedPane jTabbedPane = null;
  58     private JPanel jPanelPcd = null;
  59     private JPanel jPanelLibrary = null;
  60     private JLabel jLabelPcdData = null;
  61     private JScrollPane jScrollPaneTablePcd = null;
  62     private JTable jTablePcd = null;
  63     private JPanel jPanelPcdSouth = null;
  64     private JScrollPane jScrollPanePcdHelp = null;
  65     private JTextArea jTextAreaPcdHelp = null;
  66     private JPanel jPanelContentPaneSouth = null;
  67     private JSplitPane jSplitPane = null;
  68     private JPanel jPanelLibraryLeft = null;
  69     private JPanel jPanelLibraryRight = null;
  70     private JLabel jLabelLibClass = null;
  71     private JLabel jLabelQualifiedInstance = null;
  72     private JScrollPane jScrollPaneSelectedInstances = null;
  73     private JTable jTableSelectedInstances = null;
  74     private JScrollPane jScrollPaneLibClass = null;
  75     private JTable jTableLibClass = null;
  76     private JScrollPane jScrollPaneQualifiedInstance = null;
  77     private JTable jTableLibInstances = null;
  78     private JPanel jPanelLibrarySouth = null;
  79     private JPanel jPanelLibraryCenter = null;
  80     private JScrollPane jScrollPaneInstanceHelp = null;
  81     private JTextArea jTextAreaInstanceHelp = null;
  82     private JLabel jLabelSelectedInstances = null;
  83     private JLabel jLabelInstanceHelp = null;
  84     private JButton jButtonAdd = null;
  85     private JButton jButtonDeleteInstance = null;
  86     private JLabel jLabelPcdHelp = null;
  87     private JButton jButtonOk = null;
  88     private JButton jButtonCancel = null;
  89     private PartialEditableTableModel model = null;
  90     private LibraryTableModel selectedInstancesTableModel = null;
  91     private LibraryTableModel libClassTableModel = null;
  92     private LibraryTableModel libInstanceTableModel = null;
  93     private DefaultTableModel optionsTableModel = null;
  94     private FpdFileContents ffc = null;
  95     private String moduleKey = null;
  96     private HashMap<String, ArrayList<String>> classInstanceMap = null;
  97     private ArrayList<String> classProduced = null;
  98     private HashMap<String, ArrayList<String>> classConsumed = null;
  99     private JPanel jPanelModuleSaOpts = null;
 100     private JLabel jLabelFvBinding = null;
 101     private JTextField jTextFieldFvBinding = null;
 102     private JLabel jLabelFfsFileGuid = null;
 103     private JTextField jTextFieldFileGuid = null;
 104     private JLabel jLabelFfsFormatKey = null;
 105     private JTextField jTextFieldFfsKey = null;
 106     private JScrollPane jScrollPaneModuleSaOptions = null;
 107     private JTable jTableModuleSaOptions = null;
 108     private JButton jButtonNew = null;
 109     private JButton jButtonDeleteOption = null;
 110     private JPanel jPanelPcdFields = null;
 111     private JPanel jPanelPcdFieldsSecondRow = null;
 112     private JPanel jPanelPcdFieldsThirdRow = null;
 113     private JPanel jPanelPcdFieldsFirstRow = null;
 114     private JLabel jLabelItemType = null;
 115     private JComboBox jComboBoxItemType = null;
 116     private JLabel jLabelMaxDatumSize = null;
 117     private JTextField jTextFieldMaxDatumSize = null;
 118     private JLabel jLabelPcdDefaultValue = null;
 119     private JTextField jTextFieldPcdDefault = null;
 120     private JButton jButtonUpdatePcd = null;
 121     private JComboBox jComboBoxFeatureFlagValue = null;
 122     private OpeningPlatformType docConsole = null;
 123     private JLabel jLabelPad = null;
 124     /**
 125      * This is the default constructor
 126      */
 127     public FpdModuleSA() {
 128         super();
 129         initialize();
 130     }
 131     public FpdModuleSA(FpdFileContents ffc) {
 132         this();
 133         this.ffc = ffc;
 134     }
 135
 136     public void setKey(String k, int i, OpeningPlatformType dc){
 137         this.moduleKey = k;
 138         this.docConsole = dc;
 139         classProduced = null;
 140         classConsumed = null;
 141         jTabbedPane.setSelectedIndex(0);
 142         initPcdBuildDefinition(i);
 143     }
 144
 145     /**
 146       init will be called each time FpdModuleSA object is to be shown.
 147       @param key Module information.
 148      **/
 149     public void initPcdBuildDefinition(int i) {
 150         //
 151         // display pcd for key.
 152         //
 153         model.setRowCount(0);
 154         int pcdCount = ffc.getPcdDataCount(i);
 155         if (pcdCount != 0) {
 156             String[][] saa = new String[pcdCount][7];
 157             ffc.getPcdData(i, saa);
 158             for (int j = 0; j < saa.length; ++j) {
 159                 model.addRow(saa[j]);
 160             }
 161         }
 162     }
 163
 164     public void initLibraries(String key) {
 165         //
 166         // display library classes that need to be resolved. also potential instances for them.
 167         //
 168         resolveLibraryInstances(moduleKey);
 169         //
 170         // display lib instances already selected for key
 171         //
 172         selectedInstancesTableModel.setRowCount(0);
 173         int instanceCount = ffc.getLibraryInstancesCount(key);
 174         if (instanceCount != 0) {
 175             String[][] saa = new String[instanceCount][5];
 176             ffc.getLibraryInstances(key, saa);
 177             for (int i = 0; i < saa.length; ++i) {
 178                 ModuleIdentification mi = getModuleId(saa[i][1] + " " + saa[i][2] + " " + saa[i][3] + " " + saa[i][4]);
 179                 if (mi != null) {
 180                     saa[i][0] = mi.getName();
 181                     saa[i][2] = mi.getVersion();
 182                     saa[i][4] = mi.getPackage().getVersion();
 183                     //
 184                     // re-evaluate lib instance usage when adding a already-selected lib instance.
 185                     //
 186                     resolveLibraryInstances(saa[i][1] + " " + saa[i][2] + " " + saa[i][3] + " " + saa[i][4]);
 187                     selectedInstancesTableModel.addRow(saa[i]);
 188                 }
 189
 190
 191             }
 192         }
 193     }
 194
 195     public void initModuleSAOptions(String key) {
 196         //
 197         // display module SA options
 198         //
 199         String fvBinding = ffc.getFvBinding(key);
 200         if (fvBinding != null) {
 201             jTextFieldFvBinding.setText(fvBinding);
 202         }
 203         String fileGuid = ffc.getFfsFileNameGuid(key);
 204         if (fileGuid != null) {
 205             jTextFieldFileGuid.setText(fileGuid);
 206         }
 207         String ffsKey = ffc.getFfsFormatKey(key);
 208         if (ffsKey != null) {
 209             jTextFieldFfsKey.setText(ffsKey);
 210         }
 211
 212         optionsTableModel.setRowCount(0);
 213         String[][] saa = new String[ffc.getModuleSAOptionsCount(key)][6];
 214         ffc.getModuleSAOptions(key, saa);
 215         for (int i = 0; i < saa.length; ++i) {
 216             optionsTableModel.addRow(saa[i]);
 217         }
 218     }
 219
 220     private void resolveLibraryInstances(String key) {
 221         ModuleIdentification mi = getModuleId(key);
 222         PackageIdentification[] depPkgList = null;
 223         try{
 224             Map<String, XmlObject> m = GlobalData.getNativeMsa(mi);
 225             SurfaceAreaQuery.setDoc(m);
 226             //
 227             // Get dependency pkg list into which we will search lib instances.
 228             //
 229             depPkgList = SurfaceAreaQuery.getDependencePkg(null);
 230             //
 231             // Get the lib class consumed, produced by this module itself.
 232             //
 233             String[] classConsumed = SurfaceAreaQuery.getLibraryClasses("ALWAYS_CONSUMED");
 234
 235             if (this.classConsumed == null) {
 236                 this.classConsumed = new HashMap<String, ArrayList<String>>();
 237             }
 238
 239             for(int i = 0; i < classConsumed.length; ++i){
 240                 ArrayList<String> consumedBy = this.classConsumed.get(classConsumed[i]);
 241                 if (consumedBy == null) {
 242                     consumedBy = new ArrayList<String>();
 243                 }
 244                 consumedBy.add(key);
 245                 this.classConsumed.put(classConsumed[i], consumedBy);
 246             }
 247
 248             String[] classProduced = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED");
 249             if (this.classProduced == null) {
 250                 this.classProduced = new ArrayList<String>();
 251             }
 252             for(int i = 0; i < classProduced.length; ++i){
 253                 if (!this.classProduced.contains(classProduced[i])){
 254                     this.classProduced.add(classProduced[i]);
 255                 }
 256             }
 257             //
 258             // Get classes unresolved
 259             //
 260 //            Iterator<String> lip = this.classProduced.listIterator();
 261 //            while(lip.hasNext()){
 262 //                String clsProduced = lip.next();
 263 //                this.classConsumed.remove(clsProduced);
 264 //
 265 //            }
 266             //
 267             // find potential instances in all dependency pkgs for classes still in classConsumed.
 268             //
 269             if (classInstanceMap == null){
 270                 classInstanceMap = new HashMap<String, ArrayList<String>>();
 271             }
 272             Iterator<String> lic = this.classConsumed.keySet().iterator();
 273             while(lic.hasNext()){
 274                 String cls = lic.next();
 275                 if (this.classProduced.contains(cls) || classInstanceMap.containsKey(cls)) {
 276                     continue;
 277                 }
 278                 ArrayList<String> instances = getInstancesForClass(cls, depPkgList);
 279                 if (instances.size() == 0){
 280                     JOptionPane.showMessageDialog(frame, "No Applicable Instance for Library Class " +
 281                                                   cls + ", Platform Build will Fail.");
 282                 }
 283                 classInstanceMap.put(cls, instances);
 284
 285             }
 286
 287             showClassToResolved();
 288         }
 289         catch(Exception e) {
 290             e.printStackTrace();
 291         }
 292     }
 293
 294     private ArrayList<String> getInstancesForClass(String cls, PackageIdentification[] depPkgList) throws Exception{
 295         ArrayList<String> al = new ArrayList<String>();
 296
 297         for (int i = 0; i < depPkgList.length; ++i) {
 298             Set<ModuleIdentification> smi = GlobalData.getModules(depPkgList[i]);
 299             Iterator ismi = smi.iterator();
 300             while(ismi.hasNext()) {
 301                 ModuleIdentification mi = (ModuleIdentification)ismi.next();
 302
 303                 String[] clsProduced = getClassProduced(mi);
 304
 305                 boolean isPotential = false;
 306                 for (int j = 0; j < clsProduced.length; ++j) {
 307                     if (clsProduced[j] == null) {
 308                         continue;
 309                     }
 310                     if (clsProduced[j].equals(cls)){
 311                         isPotential = true;
 312                     }
 313                     if (classProduced.contains(clsProduced[j])) {
 314                         isPotential = false;
 315                         break;
 316                     }
 317                 }
 318                 if (isPotential) {
 319                     al.add(mi.getGuid() + " " + mi.getVersion() + " " +
 320                            depPkgList[i].getGuid() + " " + depPkgList[i].getVersion());
 321                 }
 322             }
 323         }
 324
 325         return al;
 326     }
 327
 328     private void removeInstance(String key) {
 329         ModuleIdentification mi = getModuleId(key);
 330         //
 331         // remove pcd information of instance from current ModuleSA
 332         //
 333         ffc.removePcdData(moduleKey, mi);
 334         //
 335         // remove class produced by this instance and add back these produced class to be bound.
 336         //
 337         String[] clsProduced = getClassProduced(mi);
 338         for (int i = 0; i < clsProduced.length; ++i) {
 339
 340             classProduced.remove(clsProduced[i]);
 341         }
 342         //
 343         // remove class consumed by this instance. we do not need to bound it now.
 344         //
 345         String[] clsConsumed = getClassConsumed(mi);
 346         for (int i = 0; i < clsConsumed.length; ++i) {
 347             ArrayList<String> al = classConsumed.get(clsConsumed[i]);
 348
 349             if (al == null ) {
 350                 classConsumed.remove(clsConsumed[i]);
 351                 continue;
 352             }
 353             al.remove(key);
 354             if (al.size() == 0) {
 355                 classConsumed.remove(clsConsumed[i]);
 356             }
 357
 358         }
 359
 360         showClassToResolved();
 361
 362     }
 363
 364     private ModuleIdentification getModuleId(String key){
 365         //
 366         // Get ModuleGuid, ModuleVersion, PackageGuid, PackageVersion, Arch into string array.
 367         //
 368         String[] keyPart = key.split(" ");
 369         Set<PackageIdentification> spi = GlobalData.getPackageList();
 370         Iterator ispi = spi.iterator();
 371
 372         while(ispi.hasNext()) {
 373             PackageIdentification pi = (PackageIdentification)ispi.next();
 374             if ( !pi.getGuid().equals(keyPart[2])){
 375
 376                 continue;
 377             }
 378             if (keyPart[3] != null && keyPart[3].length() > 0 && !keyPart[3].equals("null")){
 379                 if(!pi.getVersion().equals(keyPart[3])){
 380                     continue;
 381                 }
 382             }
 383             Set<ModuleIdentification> smi = GlobalData.getModules(pi);
 384             Iterator ismi = smi.iterator();
 385             while(ismi.hasNext()) {
 386                 ModuleIdentification mi = (ModuleIdentification)ismi.next();
 387                 if (mi.getGuid().equals(keyPart[0])){
 388                     if (keyPart[1] != null && keyPart[1].length() > 0 && !keyPart[1].equals("null")){
 389                         if(!mi.getVersion().equals(keyPart[1])){
 390                             continue;
 391                         }
 392                     }
 393
 394                     return mi;
 395                 }
 396             }
 397         }
 398         return null;
 399     }
 400
 401     private String[] getClassProduced(ModuleIdentification mi){
 402
 403         try{
 404             Map<String, XmlObject> m = GlobalData.getNativeMsa(mi);
 405             SurfaceAreaQuery.setDoc(m);
 406             String[] clsProduced = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED");
 407             return clsProduced;
 408
 409         }catch (Exception e) {
 410             e.printStackTrace();
 411         }
 412         return new String[0];
 413
 414     }
 415
 416     private String[] getClassConsumed(ModuleIdentification mi){
 417
 418         String[] clsConsumed = null;
 419         try{
 420             Map<String, XmlObject> m = GlobalData.getNativeMsa(mi);
 421             SurfaceAreaQuery.setDoc(m);
 422             clsConsumed = SurfaceAreaQuery.getLibraryClasses("ALWAYS_CONSUMED");
 423
 424         }catch (Exception e) {
 425             e.printStackTrace();
 426         }
 427         return clsConsumed;
 428     }
 429
 430     private void showClassToResolved(){
 431         libClassTableModel.setRowCount(0);
 432         if (classConsumed.size() == 0) {
 433             return;
 434         }
 435         Iterator<String> li = classConsumed.keySet().iterator();
 436         while(li.hasNext()){
 437
 438             String[] s = {li.next()};
 439             if (classConsumed.get(s[0]) == null) {
 440                 continue;
 441             }
 442             if (classConsumed.get(s[0]).size() == 0) {
 443                 continue;
 444             }
 445             if (!classProduced.contains(s[0])){
 446                 libClassTableModel.addRow(s);
 447             }
 448         }
 449         libInstanceTableModel.setRowCount(0);
 450     }
 451     /**
 452      * This method initializes this
 453      *
 454      * @return void
 455      */
 456     private void initialize() {
 457         this.setSize(664, 515);
 458         this.centerWindow();
 459         this.setModal(true);
 460         this.setTitle("Module Settings");
 461         this.setContentPane(getJContentPane());
 462     }
 463
 464     /**
 465      * This method initializes jContentPane
 466      *
 467      * @return javax.swing.JPanel
 468      */
 469     private JPanel getJContentPane() {
 470         if (jContentPane == null) {
 471             jContentPane = new JPanel();
 472             jContentPane.setLayout(new BorderLayout());
 473             jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
 474             jContentPane.add(getJPanelContentPaneSouth(), java.awt.BorderLayout.SOUTH);
 475         }
 476         return jContentPane;
 477     }
 478
 479     /**
 480      * This method initializes jTabbedPane
 481      *
 482      * @return javax.swing.JTabbedPane
 483      */
 484     private JTabbedPane getJTabbedPane() {
 485         if (jTabbedPane == null) {
 486             jTabbedPane = new JTabbedPane();
 487             jTabbedPane.addTab("PCD Build Definition", null, getJPanelPcd(), null);
 488             jTabbedPane.addTab("Module SA Options", null, getJPanelModuleSaOpts(), null);
 489             jTabbedPane.addTab("Libraries", null, getJPanelLibrary(), null);
 490         }
 491         return jTabbedPane;
 492     }
 493
 494     /**
 495      * This method initializes jPanelPcd
 496      *
 497      * @return javax.swing.JPanel
 498      */
 499     private JPanel getJPanelPcd() {
 500         if (jPanelPcd == null) {
 501             jLabelPcdData = new JLabel();
 502             jLabelPcdData.setText("PcdData");
 503             jPanelPcd = new JPanel();
 504             jPanelPcd.setLayout(new BorderLayout());
 505             jPanelPcd.add(jLabelPcdData, java.awt.BorderLayout.NORTH);
 506             jPanelPcd.add(getJScrollPaneTablePcd(), java.awt.BorderLayout.CENTER);
 507             jPanelPcd.add(getJPanelPcdSouth(), java.awt.BorderLayout.SOUTH);
 508             jPanelPcd.addComponentListener(new java.awt.event.ComponentAdapter() {
 509                 public void componentShown(java.awt.event.ComponentEvent e) {
 510 //                    initPcdBuildDefinition(moduleKey);
 511                 }
 512             });
 513
 514         }
 515         return jPanelPcd;
 516     }
 517
 518     /**
 519      * This method initializes jPanelLibrary
 520      *
 521      * @return javax.swing.JPanel
 522      */
 523     private JPanel getJPanelLibrary() {
 524         if (jPanelLibrary == null) {
 525             jPanelLibrary = new JPanel();
 526             jPanelLibrary.setLayout(new BorderLayout());
 527             jPanelLibrary.add(getJSplitPane(), java.awt.BorderLayout.NORTH);
 528             jPanelLibrary.add(getJPanelLibrarySouth(), java.awt.BorderLayout.SOUTH);
 529             jPanelLibrary.add(getJPanelLibraryCenter(), java.awt.BorderLayout.CENTER);
 530             jPanelLibrary.addComponentListener(new java.awt.event.ComponentAdapter() {
 531                 public void componentShown(java.awt.event.ComponentEvent e) {
 532                     initLibraries(moduleKey);
 533                 }
 534             });
 535         }
 536         return jPanelLibrary;
 537     }
 538
 539     /**
 540      * This method initializes jScrollPaneTablePcd
 541      *
 542      * @return javax.swing.JScrollPane
 543      */
 544     private JScrollPane getJScrollPaneTablePcd() {
 545         if (jScrollPaneTablePcd == null) {
 546             jScrollPaneTablePcd = new JScrollPane();
 547             jScrollPaneTablePcd.setViewportView(getJTablePcd());
 548         }
 549         return jScrollPaneTablePcd;
 550     }
 551
 552     /**
 553      * This method initializes jTable
 554      *
 555      * @return javax.swing.JTable
 556      */
 557     private JTable getJTablePcd() {
 558         if (jTablePcd == null) {
 559             model = new PartialEditableTableModel();
 560             jTablePcd = new JTable(model);
 561             jTablePcd.setRowHeight(20);
 562             jTablePcd.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
 563             model.addColumn("CName");
 564             model.addColumn("TokenSpaceGUID");
 565             model.addColumn("ItemType");
 566             model.addColumn("Token");
 567             model.addColumn("MaxDatumSize");
 568             model.addColumn("DataType");
 569             model.addColumn("DefaultValue");
 570
 571             jTablePcd.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 572             jTablePcd.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 573                 public void valueChanged(ListSelectionEvent e) {
 574
 575                     if (e.getValueIsAdjusting()){
 576                         return;
 577                     }
 578                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 579                     if (lsm.isSelectionEmpty()) {
 580                         return;
 581                     }
 582                     else{
 583                         int selectedRow = lsm.getMinSelectionIndex();
 584                         String cName = jTablePcd.getValueAt(selectedRow, 0)+"";
 585                         String[] pcdInfo = {"", ""};
 586                         getPcdInfo(cName, pcdInfo);
 587                         jTextAreaPcdHelp.setText(pcdInfo[0]);
 588                         initComboBox(pcdInfo[1]);
 589                         jComboBoxItemType.setSelectedItem(pcdInfo[1]);
 590                         jTextFieldMaxDatumSize.setEnabled(true);
 591                         jTextFieldMaxDatumSize.setVisible(true);
 592                         jTextFieldMaxDatumSize.setText(jTablePcd.getValueAt(selectedRow, 4)+"");
 593                         jTextFieldPcdDefault.setEnabled(true);
 594                         jTextFieldPcdDefault.setText(jTablePcd.getValueAt(selectedRow, 6)+"");
 595                         if (jTablePcd.getValueAt(selectedRow, 5).equals("VOID*")) {
 596                             if (pcdInfo[1].equals("FEATURE_FLAG")) {
 597                                 jTextFieldMaxDatumSize.setVisible(false);
 598                             }
 599                             else if (pcdInfo[1].equals("FIXED_AT_BUILD")) {
 600                                 try{
 601                                     jTextFieldMaxDatumSize.setEnabled(false);
 602                                     jTextFieldMaxDatumSize.setText(ffc.setMaxSizeForPointer(jTablePcd.getValueAt(selectedRow, 6)+"")+"");
 603                                 }
 604                                 catch(Exception except){
 605                                     JOptionPane.showMessageDialog(frame, "Unacceptable PCD Value: " + except.getMessage());
 606                                 }
 607                             }
 608                             else{
 609                                 jTextFieldMaxDatumSize.setText(jTablePcd.getValueAt(selectedRow, 4)+"");
 610                             }
 611                         }
 612                         else {
 613                             jTextFieldMaxDatumSize.setEnabled(false);
 614                         }
 615
 616                         if (!jTablePcd.getValueAt(selectedRow, 2).equals("DYNAMIC") && !jTablePcd.getValueAt(selectedRow, 2).equals("DYNAMIC_EX")) {
 617                             jTextFieldPcdDefault.setText(jTablePcd.getValueAt(selectedRow, 6)+"");
 618                             if (jTablePcd.getValueAt(selectedRow, 2).equals("FEATURE_FLAG")){
 619                                 jTextFieldPcdDefault.setVisible(false);
 620                                 jComboBoxFeatureFlagValue.setVisible(true);
 621                                 jComboBoxFeatureFlagValue.setSelectedItem(jTablePcd.getValueAt(selectedRow, 6)+"");
 622                             }
 623                             else{
 624                                 jTextFieldPcdDefault.setVisible(true);
 625                                 jTextFieldPcdDefault.setEnabled(true);
 626                                 jComboBoxFeatureFlagValue.setVisible(false);
 627                             }
 628                         }
 629                         else{
 630                             jTextFieldPcdDefault.setEnabled(false);
 631                         }
 632                     }
 633
 634
 635                 }
 636             });
 637
 638             jTablePcd.getModel().addTableModelListener(new TableModelListener() {
 639                 public void tableChanged(TableModelEvent arg0) {
 640                     // TODO Auto-generated method stub
 641 //                    int row = arg0.getFirstRow();
 642 //                    TableModel m = (TableModel)arg0.getSource();
 643
 644                     if (arg0.getType() == TableModelEvent.UPDATE){
 645                         //update xml doc here.
 646
 647                     }
 648                 }
 649             });
 650         }
 651         return jTablePcd;
 652     }
 653
 654     private void initComboBox(String originalType) {
 655         jComboBoxItemType.removeAllItems();
 656         jComboBoxItemType.addItem(originalType);
 657         if (originalType.equals("PATCHABLE_IN_MODULE")) {
 658             jComboBoxItemType.addItem("FIXED_AT_BUILD");
 659         }
 660         if (originalType.equals("DYNAMIC")) {
 661             jComboBoxItemType.addItem("FIXED_AT_BUILD");
 662             jComboBoxItemType.addItem("PATCHABLE_IN_MODULE");
 663         }
 664     }
 665
 666     private void getPcdInfo(String cName, String[] sa) {
 667         String[][] saa = new String[ffc.getLibraryInstancesCount(moduleKey)][5];
 668         ffc.getLibraryInstances(moduleKey, saa);
 669
 670         try{
 671             if (ffc.getPcdBuildDataInfo(getModuleId(moduleKey), cName, sa)) {
 672                 return;
 673             }
 674             for (int j = 0; j < saa.length; ++j) {
 675                 if (ffc.getPcdBuildDataInfo(getModuleId(saa[j][1] + " " + saa[j][2] + " " + saa[j][3] + " " + saa[j][4]),
 676                                             cName, sa)) {
 677                     return;
 678                 }
 679             }
 680         }
 681         catch(Exception e) {
 682             JOptionPane.showMessageDialog(this, "Get PCD details fail: " + e.getMessage());
 683         }
 684     }
 685
 686     /**
 687      * This method initializes jPanelPcdSouth
 688      *
 689      * @return javax.swing.JPanel
 690      */
 691     private JPanel getJPanelPcdSouth() {
 692         if (jPanelPcdSouth == null) {
 693             jLabelPcdHelp = new JLabel();
 694             jLabelPcdHelp.setText("PCD Description");
 695             jPanelPcdSouth = new JPanel();
 696             jPanelPcdSouth.setPreferredSize(new java.awt.Dimension(607,200));
 697             jPanelPcdSouth.add(jLabelPcdHelp, null);
 698             jPanelPcdSouth.add(getJScrollPanePcdHelp(), null);
 699             jPanelPcdSouth.add(getJPanelPcdFields(), null);
 700         }
 701         return jPanelPcdSouth;
 702     }
 703
 704     /**
 705      * This method initializes jScrollPanePcdHelp
 706      *
 707      * @return javax.swing.JScrollPane
 708      */
 709     private JScrollPane getJScrollPanePcdHelp() {
 710         if (jScrollPanePcdHelp == null) {
 711             jScrollPanePcdHelp = new JScrollPane();
 712             jScrollPanePcdHelp.setPreferredSize(new java.awt.Dimension(500,100));
 713             jScrollPanePcdHelp.setViewportView(getJTextAreaPcdHelp());
 714         }
 715         return jScrollPanePcdHelp;
 716     }
 717
 718     /**
 719      * This method initializes jTextAreaPcdHelp
 720      *
 721      * @return javax.swing.JTextArea
 722      */
 723     private JTextArea getJTextAreaPcdHelp() {
 724         if (jTextAreaPcdHelp == null) {
 725             jTextAreaPcdHelp = new JTextArea();
 726             jTextAreaPcdHelp.setEditable(false);
 727         }
 728         return jTextAreaPcdHelp;
 729     }
 730
 731     /**
 732      * This method initializes jPanelContentPaneSouth
 733      *
 734      * @return javax.swing.JPanel
 735      */
 736     private JPanel getJPanelContentPaneSouth() {
 737         if (jPanelContentPaneSouth == null) {
 738             FlowLayout flowLayout = new FlowLayout();
 739             flowLayout.setAlignment(java.awt.FlowLayout.RIGHT);
 740             jPanelContentPaneSouth = new JPanel();
 741             jPanelContentPaneSouth.setLayout(flowLayout);
 742             jPanelContentPaneSouth.add(getJButtonOk(), null);
 743             jPanelContentPaneSouth.add(getJButtonCancel(), null);
 744         }
 745         return jPanelContentPaneSouth;
 746     }
 747
 748     /**
 749      * This method initializes jSplitPane
 750      *
 751      * @return javax.swing.JSplitPane
 752      */
 753     private JSplitPane getJSplitPane() {
 754         if (jSplitPane == null) {
 755             jSplitPane = new JSplitPane();
 756             jSplitPane.setDividerLocation(200);
 757             jSplitPane.setLeftComponent(getJPanelLibraryLeft());
 758             jSplitPane.setRightComponent(getJPanelLibraryRight());
 759             jSplitPane.setPreferredSize(new java.awt.Dimension(202,200));
 760         }
 761         return jSplitPane;
 762     }
 763
 764     /**
 765      * This method initializes jPanelLibraryLeft
 766      *
 767      * @return javax.swing.JPanel
 768      */
 769     private JPanel getJPanelLibraryLeft() {
 770         if (jPanelLibraryLeft == null) {
 771             jLabelLibClass = new JLabel();
 772             jLabelLibClass.setText("Library Classes Uninstantiated");
 773             jPanelLibraryLeft = new JPanel();
 774             jPanelLibraryLeft.add(jLabelLibClass, null);
 775             jPanelLibraryLeft.add(getJScrollPaneLibClass(), null);
 776         }
 777         return jPanelLibraryLeft;
 778     }
 779
 780     /**
 781      * This method initializes jPanelLibraryRight
 782      *
 783      * @return javax.swing.JPanel
 784      */
 785     private JPanel getJPanelLibraryRight() {
 786         if (jPanelLibraryRight == null) {
 787             jLabelQualifiedInstance = new JLabel();
 788             jLabelQualifiedInstance.setText("Instances Available");
 789             jPanelLibraryRight = new JPanel();
 790             jPanelLibraryRight.add(jLabelQualifiedInstance, null);
 791             jPanelLibraryRight.add(getJScrollPaneQualifiedInstance(), null);
 792         }
 793         return jPanelLibraryRight;
 794     }
 795
 796     /**
 797      * This method initializes jScrollPaneSelectedInstances
 798      *
 799      * @return javax.swing.JScrollPane
 800      */
 801     private JScrollPane getJScrollPaneSelectedInstances() {
 802         if (jScrollPaneSelectedInstances == null) {
 803             jScrollPaneSelectedInstances = new JScrollPane();
 804             jScrollPaneSelectedInstances.setPreferredSize(new java.awt.Dimension(453,150));
 805             jScrollPaneSelectedInstances.setViewportView(getJTableSelectedInstances());
 806         }
 807         return jScrollPaneSelectedInstances;
 808     }
 809
 810     /**
 811      * This method initializes jTableSelectedInstances
 812      *
 813      * @return javax.swing.JTable
 814      */
 815     private JTable getJTableSelectedInstances() {
 816         if (jTableSelectedInstances == null) {
 817             selectedInstancesTableModel = new LibraryTableModel();
 818             selectedInstancesTableModel.addColumn("Name");
 819             selectedInstancesTableModel.addColumn("ModuleGUID");
 820             selectedInstancesTableModel.addColumn("ModuleVersion");
 821             selectedInstancesTableModel.addColumn("PackageGUID");
 822             selectedInstancesTableModel.addColumn("PackageVersion");
 823             jTableSelectedInstances = new JTable(selectedInstancesTableModel);
 824             jTableSelectedInstances.setRowHeight(20);
 825             jTableSelectedInstances.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
 826             jTableSelectedInstances.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 827
 828         }
 829         return jTableSelectedInstances;
 830     }
 831
 832     /**
 833      * This method initializes jScrollPaneLibClass
 834      *
 835      * @return javax.swing.JScrollPane
 836      */
 837     private JScrollPane getJScrollPaneLibClass() {
 838         if (jScrollPaneLibClass == null) {
 839             jScrollPaneLibClass = new JScrollPane();
 840             jScrollPaneLibClass.setPreferredSize(new java.awt.Dimension(200,170));
 841             jScrollPaneLibClass.setViewportView(getJTableLibClass());
 842         }
 843         return jScrollPaneLibClass;
 844     }
 845
 846     /**
 847      * This method initializes jTableLibClass
 848      *
 849      * @return javax.swing.JTable
 850      */
 851     private JTable getJTableLibClass() {
 852         if (jTableLibClass == null) {
 853             libClassTableModel = new LibraryTableModel();
 854             libClassTableModel.addColumn("LibraryClass");
 855             jTableLibClass = new JTable(libClassTableModel);
 856             jTableLibClass.setRowHeight(20);
 857             jTableLibClass.setShowGrid(false);
 858             jTableLibClass.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 859             jTableLibClass.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
 860                 public void valueChanged(ListSelectionEvent e) {
 861                     if (e.getValueIsAdjusting()){
 862                         return;
 863                     }
 864                     ListSelectionModel lsm = (ListSelectionModel)e.getSource();
 865                     if (lsm.isSelectionEmpty()) {
 866                         return;
 867                     }
 868                     else{
 869                         int selectedRow2 = lsm.getMinSelectionIndex();
 870                         if (selectedRow2 < 0) {
 871                             return;
 872                         }
 873                         //
 874                         // display potential lib instances according to class selection
 875                         //
 876                         libInstanceTableModel.setRowCount(0);
 877                         String cls = libClassTableModel.getValueAt(selectedRow2, 0).toString();
 878                         ArrayList<String> al = classInstanceMap.get(cls);
 879                         ListIterator<String> li = al.listIterator();
 880                         while(li.hasNext()) {
 881                             String instance = li.next();
 882                             String[] s = {"", "", "", "", ""};
 883                             if (getModuleId(instance) != null) {
 884                                 s[0] = getModuleId(instance).getName();
 885                             }
 886
 887                             String[] instancePart = instance.split(" ");
 888                             for (int i = 0; i < instancePart.length; ++i){
 889                                 s[i+1] = instancePart[i];
 890                             }
 891                             libInstanceTableModel.addRow(s);
 892                         }
 893
 894                     }
 895                 }
 896             });
 897         }
 898         return jTableLibClass;
 899     }
 900
 901     /**
 902      * This method initializes jScrollPaneQualifiedInstance
 903      *
 904      * @return javax.swing.JScrollPane
 905      */
 906     private JScrollPane getJScrollPaneQualifiedInstance() {
 907         if (jScrollPaneQualifiedInstance == null) {
 908             jScrollPaneQualifiedInstance = new JScrollPane();
 909             jScrollPaneQualifiedInstance.setPreferredSize(new java.awt.Dimension(430,170));
 910             jScrollPaneQualifiedInstance.setViewportView(getJTableLibInstances());
 911         }
 912         return jScrollPaneQualifiedInstance;
 913     }
 914
 915     /**
 916      * This method initializes jTableLibInstances
 917      *
 918      * @return javax.swing.JTable
 919      */
 920     private JTable getJTableLibInstances() {
 921         if (jTableLibInstances == null) {
 922             libInstanceTableModel = new LibraryTableModel();
 923             libInstanceTableModel.addColumn("Name");
 924             libInstanceTableModel.addColumn("ModuleGUID");
 925             libInstanceTableModel.addColumn("ModuleVersion");
 926             libInstanceTableModel.addColumn("PackageGUID");
 927             libInstanceTableModel.addColumn("PackageVersion");
 928             jTableLibInstances = new JTable(libInstanceTableModel);
 929             jTableLibInstances.setRowHeight(20);
 930             jTableLibInstances.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
 931             jTableLibInstances.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 932
 933         }
 934         return jTableLibInstances;
 935     }
 936
 937     /**
 938      * This method initializes jPanelLibrarySouth
 939      *
 940      * @return javax.swing.JPanel
 941      */
 942     private JPanel getJPanelLibrarySouth() {
 943         if (jPanelLibrarySouth == null) {
 944             jPanelLibrarySouth = new JPanel();
 945         }
 946         return jPanelLibrarySouth;
 947     }
 948
 949     /**
 950      * This method initializes jPanelLibraryCenter
 951      *
 952      * @return javax.swing.JPanel
 953      */
 954     private JPanel getJPanelLibraryCenter() {
 955         if (jPanelLibraryCenter == null) {
 956             jLabelInstanceHelp = new JLabel();
 957             jLabelInstanceHelp.setText("Instance Description");
 958             jLabelSelectedInstances = new JLabel();
 959             jLabelSelectedInstances.setText("Selected Instances");
 960             jPanelLibraryCenter = new JPanel();
 961             jPanelLibraryCenter.add(jLabelInstanceHelp, null);
 962             jPanelLibraryCenter.add(getJScrollPaneInstanceHelp(), null);
 963             jPanelLibraryCenter.add(getJButtonAdd(), null);
 964             jPanelLibraryCenter.add(getJButtonDeleteInstance(), null);
 965             jPanelLibraryCenter.add(jLabelSelectedInstances, null);
 966             jPanelLibraryCenter.add(getJScrollPaneSelectedInstances(), null);
 967         }
 968         return jPanelLibraryCenter;
 969     }
 970
 971     /**
 972      * This method initializes jScrollPaneInstanceHelp
 973      *
 974      * @return javax.swing.JScrollPane
 975      */
 976     private JScrollPane getJScrollPaneInstanceHelp() {
 977         if (jScrollPaneInstanceHelp == null) {
 978             jScrollPaneInstanceHelp = new JScrollPane();
 979             jScrollPaneInstanceHelp.setPreferredSize(new java.awt.Dimension(300,50));
 980             jScrollPaneInstanceHelp.setViewportView(getJTextAreaInstanceHelp());
 981         }
 982         return jScrollPaneInstanceHelp;
 983     }
 984
 985     /**
 986      * This method initializes jTextAreaInstanceHelp
 987      *
 988      * @return javax.swing.JTextArea
 989      */
 990     private JTextArea getJTextAreaInstanceHelp() {
 991         if (jTextAreaInstanceHelp == null) {
 992             jTextAreaInstanceHelp = new JTextArea();
 993             jTextAreaInstanceHelp.setEditable(false);
 994         }
 995         return jTextAreaInstanceHelp;
 996     }
 997
 998     /**
 999      * This method initializes jButtonAdd
1000      *
1001      * @return javax.swing.JButton
1002      */
1003     private JButton getJButtonAdd() {
1004         if (jButtonAdd == null) {
1005             jButtonAdd = new JButton();
1006             jButtonAdd.setPreferredSize(new java.awt.Dimension(80,20));
1007             jButtonAdd.setText("Add");
1008             jButtonAdd.addActionListener(new java.awt.event.ActionListener() {
1009                 public void actionPerformed(java.awt.event.ActionEvent e) {
1010                     int row = jTableLibInstances.getSelectedRow();
1011                     if (row < 0) {
1012                         return;
1013                     }
1014                     docConsole.setSaved(false);
1015                     Object[] s = {libInstanceTableModel.getValueAt(row, 0), libInstanceTableModel.getValueAt(row, 1),
1016                                   libInstanceTableModel.getValueAt(row, 2), libInstanceTableModel.getValueAt(row, 3),
1017                                   libInstanceTableModel.getValueAt(row, 4)};
1018                     selectedInstancesTableModel.addRow(s);
1019                     String instanceValue = libInstanceTableModel.getValueAt(row, 1) + " " +
1020                     libInstanceTableModel.getValueAt(row, 2) + " " +
1021                     libInstanceTableModel.getValueAt(row, 3) + " " +
1022                     libInstanceTableModel.getValueAt(row, 4);
1023                     ModuleIdentification libMi = getModuleId(instanceValue);
1024                     ffc.genLibraryInstance(libMi, moduleKey);
1025                     //
1026                     // Add pcd information of selected instance to current moduleSA
1027                     //
1028                     try{
1029                         ffc.addFrameworkModulesPcdBuildDefs(libMi, null, ffc.getModuleSA(moduleKey));
1030                     }
1031                     catch (Exception exception) {
1032                         JOptionPane.showMessageDialog(frame, "PCD Insertion Fail. " + exception.getMessage());
1033                     }
1034                     resolveLibraryInstances(instanceValue);
1035                 }
1036             });
1037         }
1038         return jButtonAdd;
1039     }
1040
1041     /**
1042      * This method initializes jButton1
1043      *
1044      * @return javax.swing.JButton
1045      */
1046     private JButton getJButtonDeleteInstance() {
1047         if (jButtonDeleteInstance == null) {
1048             jButtonDeleteInstance = new JButton();
1049             jButtonDeleteInstance.setPreferredSize(new java.awt.Dimension(80,20));
1050             jButtonDeleteInstance.setText("Delete");
1051             jButtonDeleteInstance.addActionListener(new java.awt.event.ActionListener() {
1052                 public void actionPerformed(java.awt.event.ActionEvent e) {
1053                     int row = jTableSelectedInstances.getSelectedRow();
1054                     if (row < 0) {
1055                         return;
1056                     }
1057                     docConsole.setSaved(false);
1058                     removeInstance(selectedInstancesTableModel.getValueAt(row, 1) + " " +
1059                                    selectedInstancesTableModel.getValueAt(row, 2) + " " +
1060                                    selectedInstancesTableModel.getValueAt(row, 3) + " " +
1061                                    selectedInstancesTableModel.getValueAt(row, 4));
1062                     ffc.removeLibraryInstance(moduleKey, row);
1063                     selectedInstancesTableModel.removeRow(row);
1064
1065                 }
1066             });
1067         }
1068         return jButtonDeleteInstance;
1069     }
1070
1071     /**
1072      * This method initializes jButton2
1073      *
1074      * @return javax.swing.JButton
1075      */
1076     private JButton getJButtonOk() {
1077         if (jButtonOk == null) {
1078             jButtonOk = new JButton();
1079             jButtonOk.setPreferredSize(new java.awt.Dimension(80,20));
1080             jButtonOk.setText("Ok");
1081             jButtonOk.addActionListener(this);
1082         }
1083         return jButtonOk;
1084     }
1085
1086     /**
1087      * This method initializes jButton3
1088      *
1089      * @return javax.swing.JButton
1090      */
1091     private JButton getJButtonCancel() {
1092         if (jButtonCancel == null) {
1093             jButtonCancel = new JButton();
1094             jButtonCancel.setPreferredSize(new java.awt.Dimension(80,20));
1095             jButtonCancel.setText("Cancel");
1096             jButtonCancel.setVisible(false);
1097         }
1098         return jButtonCancel;
1099     }
1100     public void actionPerformed(ActionEvent arg0) {
1101
1102         if (arg0.getSource() == jButtonOk) {
1103             if (jTableModuleSaOptions.isEditing()) {
1104                 jTableModuleSaOptions.getCellEditor().stopCellEditing();
1105             }
1106             this.setVisible(false);
1107         }
1108     }
1109     /**
1110      * This method initializes jPanelModuleSaOpts
1111      *
1112      * @return javax.swing.JPanel
1113      */
1114     private JPanel getJPanelModuleSaOpts() {
1115         if (jPanelModuleSaOpts == null) {
1116             jLabelPad = new JLabel();
1117             jLabelPad.setText("");
1118             jLabelPad.setPreferredSize(new java.awt.Dimension(250,16));
1119             FlowLayout flowLayout4 = new FlowLayout();
1120             flowLayout4.setAlignment(java.awt.FlowLayout.LEFT);
1121             jLabelFfsFormatKey = new JLabel();
1122             jLabelFfsFormatKey.setText("FFS Format Key");
1123             jLabelFfsFormatKey.setPreferredSize(new java.awt.Dimension(90,16));
1124             jLabelFfsFileGuid = new JLabel();
1125             jLabelFfsFileGuid.setText("FFS File GUID");
1126             jLabelFfsFileGuid.setPreferredSize(new java.awt.Dimension(90,16));
1127             jLabelFvBinding = new JLabel();
1128             jLabelFvBinding.setText("FV Binding");
1129             jLabelFvBinding.setPreferredSize(new java.awt.Dimension(90,16));
1130             jPanelModuleSaOpts = new JPanel();
1131             jPanelModuleSaOpts.setLayout(flowLayout4);
1132             jPanelModuleSaOpts.add(jLabelFvBinding, null);
1133             jPanelModuleSaOpts.add(getJTextFieldFvBinding(), null);
1134             jPanelModuleSaOpts.add(jLabelFfsFileGuid, null);
1135             jPanelModuleSaOpts.add(getJTextFieldFileGuid(), null);
1136             jPanelModuleSaOpts.add(jLabelFfsFormatKey, null);
1137             jPanelModuleSaOpts.add(getJTextFieldFfsKey(), null);
1138             jPanelModuleSaOpts.add(getJScrollPaneModuleSaOptions(), null);
1139             jPanelModuleSaOpts.add(jLabelPad, null);
1140             jPanelModuleSaOpts.add(getJButtonNew(), null);
1141             jPanelModuleSaOpts.add(getJButtonDeleteOption(), null);
1142             jPanelModuleSaOpts.addComponentListener(new java.awt.event.ComponentAdapter() {
1143                 public void componentShown(java.awt.event.ComponentEvent e) {
1144                     initModuleSAOptions(moduleKey);
1145                 }
1146             });
1147         }
1148         return jPanelModuleSaOpts;
1149     }
1150     /**
1151      * This method initializes jTextField
1152      *
1153      * @return javax.swing.JTextField
1154      */
1155     private JTextField getJTextFieldFvBinding() {
1156         if (jTextFieldFvBinding == null) {
1157             jTextFieldFvBinding = new JTextField();
1158             jTextFieldFvBinding.setPreferredSize(new java.awt.Dimension(150,20));
1159             jTextFieldFvBinding.addFocusListener(new java.awt.event.FocusAdapter() {
1160                 public void focusLost(java.awt.event.FocusEvent e) {
1161                     String originalFvBinding = ffc.getFvBinding(moduleKey);
1162                     String newFvBinding = jTextFieldFvBinding.getText();
1163                     if (newFvBinding.equals(originalFvBinding)) {
1164                         return;
1165                     }
1166                     if (newFvBinding.length() == 0 && originalFvBinding == null) {
1167                         return;
1168                     }
1169                     docConsole.setSaved(false);
1170                     ffc.setFvBinding(moduleKey, newFvBinding);
1171                 }
1172             });
1173
1174         }
1175         return jTextFieldFvBinding;
1176     }
1177     /**
1178      * This method initializes jTextField1
1179      *
1180      * @return javax.swing.JTextField
1181      */
1182     private JTextField getJTextFieldFileGuid() {
1183         if (jTextFieldFileGuid == null) {
1184             jTextFieldFileGuid = new JTextField();
1185             jTextFieldFileGuid.setPreferredSize(new java.awt.Dimension(300,20));
1186             jTextFieldFileGuid.addFocusListener(new java.awt.event.FocusAdapter() {
1187                 public void focusLost(java.awt.event.FocusEvent e) {
1188                     String originalFileGuid = ffc.getFfsFileNameGuid(moduleKey);
1189                     String newFileGuid = jTextFieldFileGuid.getText();
1190                     if (newFileGuid.equals(originalFileGuid)) {
1191                         return;
1192                     }
1193                     if (newFileGuid.length() == 0 && originalFileGuid == null) {
1194                         return;
1195                     }
1196                     if (newFileGuid.length() > 0) {
1197                         if (!DataValidation.isGuid(newFileGuid)) {
1198                             JOptionPane.showMessageDialog(frame, "FFS File Guid is NOT GUID Type.");
1199                             return;
1200                         }
1201                     }
1202
1203                     docConsole.setSaved(false);
1204                     if (newFileGuid.length() == 0) {
1205                         newFileGuid = null;
1206                     }
1207                     ffc.setFfsFileNameGuid(moduleKey, newFileGuid);
1208                 }
1209             });
1210
1211         }
1212         return jTextFieldFileGuid;
1213     }
1214     /**
1215      * This method initializes jTextFieldFfsKey
1216      *
1217      * @return javax.swing.JTextField
1218      */
1219     private JTextField getJTextFieldFfsKey() {
1220         if (jTextFieldFfsKey == null) {
1221             jTextFieldFfsKey = new JTextField();
1222             jTextFieldFfsKey.setPreferredSize(new java.awt.Dimension(150,20));
1223             jTextFieldFfsKey.addFocusListener(new java.awt.event.FocusAdapter() {
1224                 public void focusLost(java.awt.event.FocusEvent e) {
1225                     String originalFfsKey = ffc.getFfsFormatKey(moduleKey);
1226                     String newFfsKey = jTextFieldFfsKey.getText();
1227                     if (newFfsKey.equals(originalFfsKey)) {
1228                         return;
1229                     }
1230                     if (newFfsKey.length() == 0 && originalFfsKey == null) {
1231                         return;
1232                     }
1233                     docConsole.setSaved(false);
1234                     ffc.setFfsFormatKey(moduleKey, newFfsKey);
1235                 }
1236             });
1237
1238         }
1239         return jTextFieldFfsKey;
1240     }
1241     /**
1242      * This method initializes jScrollPaneModuleSaOptions
1243      *
1244      * @return javax.swing.JScrollPane
1245      */
1246     private JScrollPane getJScrollPaneModuleSaOptions() {
1247         if (jScrollPaneModuleSaOptions == null) {
1248             jScrollPaneModuleSaOptions = new JScrollPane();
1249             jScrollPaneModuleSaOptions.setPreferredSize(new java.awt.Dimension(600,200));
1250             jScrollPaneModuleSaOptions.setViewportView(getJTableModuleSaOptions());
1251         }
1252         return jScrollPaneModuleSaOptions;
1253     }
1254     /**
1255      * This method initializes jTableModuleSaOptions
1256      *
1257      * @return javax.swing.JTable
1258      */
1259     private JTable getJTableModuleSaOptions() {
1260         if (jTableModuleSaOptions == null) {
1261             optionsTableModel = new DefaultTableModel();
1262             optionsTableModel.addColumn("BuildTargets");
1263             optionsTableModel.addColumn("ToolChainFamily");
1264             optionsTableModel.addColumn("TagName");
1265             optionsTableModel.addColumn("ToolCode");
1266             optionsTableModel.addColumn("SupportedArchs");
1267             optionsTableModel.addColumn("Contents");
1268             jTableModuleSaOptions = new JTable(optionsTableModel);
1269             jTableModuleSaOptions.setRowHeight(20);
1270             Vector<String> vArch = new Vector<String>();
1271             vArch.add("IA32");
1272             vArch.add("X64");
1273             vArch.add("IPF");
1274             vArch.add("EBC");
1275             vArch.add("ARM");
1276             vArch.add("PPC");
1277             jTableModuleSaOptions.getColumnModel().getColumn(4).setCellEditor(new ListEditor(vArch));
1278             jTableModuleSaOptions.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
1279                         jTableModuleSaOptions.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
1280             jTableModuleSaOptions.getModel().addTableModelListener(new TableModelListener() {
1281                 public void tableChanged(TableModelEvent arg0) {
1282                     // TODO Auto-generated method stub
1283                     int row = arg0.getFirstRow();
1284                     TableModel m = (TableModel)arg0.getSource();
1285
1286                     if (arg0.getType() == TableModelEvent.UPDATE){
1287                         //ToDo Data Validition check.
1288                         String targets = m.getValueAt(row, 0) + "";
1289                         Vector<Object> targetName = null;
1290                         if (targets.length() > 0) {
1291                             targetName = new Vector<Object>();
1292                             String[] sArray = targets.split(" ");
1293                             for (int i = 0; i < sArray.length; ++i) {
1294                                 targetName.add(sArray[i]);
1295                             }
1296                         }
1297
1298                         String toolChain = m.getValueAt(row, 1) + "";
1299                         String tagName = m.getValueAt(row, 2) + "";
1300                         String toolCode = m.getValueAt(row, 3) + "";
1301                         String archs = m.getValueAt(row, 4) + "";
1302                         Vector<Object> supArch = null;
1303                         if (archs.length() > 0) {
1304                             supArch = new Vector<Object>();
1305                             String[] sArray1 = archs.split(" ");
1306                             for (int i = 0; i < sArray1.length; ++i) {
1307                                 supArch.add(sArray1[i]);
1308                             }
1309                         }
1310
1311                         String contents = m.getValueAt(row, 5) + "";
1312                         docConsole.setSaved(false);
1313                         ffc.updateModuleSAOptionsOpt(moduleKey, row, targetName, toolChain, tagName, toolCode, supArch, contents);
1314                     }
1315                 }
1316             });
1317         }
1318         return jTableModuleSaOptions;
1319     }
1320     /**
1321      * This method initializes jButtonNew
1322      *
1323      * @return javax.swing.JButton
1324      */
1325     private JButton getJButtonNew() {
1326         if (jButtonNew == null) {
1327             jButtonNew = new JButton();
1328             jButtonNew.setPreferredSize(new java.awt.Dimension(80,20));
1329             jButtonNew.setText("New");
1330             jButtonNew.addActionListener(new java.awt.event.ActionListener() {
1331                 public void actionPerformed(java.awt.event.ActionEvent e) {
1332                     String[] row = {"", "", "", "", "", ""};
1333                     optionsTableModel.addRow(row);
1334                     Vector<Object> v = new Vector<Object>();
1335                     Vector<Object> v1 = null;
1336                     docConsole.setSaved(false);
1337                     ffc.genModuleSAOptionsOpt(moduleKey, v, "", "", "", v1, "");
1338                 }
1339             });
1340         }
1341         return jButtonNew;
1342     }
1343     /**
1344      * This method initializes jButtonDelete
1345      *
1346      * @return javax.swing.JButton
1347      */
1348     private JButton getJButtonDeleteOption() {
1349         if (jButtonDeleteOption == null) {
1350             jButtonDeleteOption = new JButton();
1351             jButtonDeleteOption.setPreferredSize(new java.awt.Dimension(80,20));
1352             jButtonDeleteOption.setText("Delete");
1353             jButtonDeleteOption.addActionListener(new java.awt.event.ActionListener() {
1354                 public void actionPerformed(java.awt.event.ActionEvent e) {
1355                     if (jTableModuleSaOptions.getSelectedRow() < 0) {
1356                         return;
1357                     }
1358                     docConsole.setSaved(false);
1359                     ffc.removeModuleSAOptionsOpt(moduleKey, jTableModuleSaOptions.getSelectedRow());
1360                     optionsTableModel.removeRow(jTableModuleSaOptions.getSelectedRow());
1361                 }
1362             });
1363         }
1364         return jButtonDeleteOption;
1365     }
1366
1367     /**
1368     Start the window at the center of screen
1369
1370     **/
1371    protected void centerWindow(int intWidth, int intHeight) {
1372        Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
1373        this.setLocation((d.width - intWidth) / 2, (d.height - intHeight) / 2);
1374    }
1375
1376    /**
1377     Start the window at the center of screen
1378
1379     **/
1380    protected void centerWindow() {
1381        centerWindow(this.getSize().width, this.getSize().height);
1382    }
1383 /**
1384  * This method initializes jPanelPcdFields
1385  *
1386  * @return javax.swing.JPanel
1387  */
1388 private JPanel getJPanelPcdFields() {
1389     if (jPanelPcdFields == null) {
1390         GridLayout gridLayout = new GridLayout();
1391         gridLayout.setRows(3);
1392         gridLayout.setColumns(2);
1393         jPanelPcdFields = new JPanel();
1394         jPanelPcdFields.setLayout(gridLayout);
1395         jPanelPcdFields.setPreferredSize(new java.awt.Dimension(600,90));
1396         jPanelPcdFields.add(getJPanelPcdFieldsFirstRow(), null);
1397         jPanelPcdFields.add(getJPanelPcdFieldsSecondRow(), null);
1398         jPanelPcdFields.add(getJPanelPcdFieldsThirdRow(), null);
1399     }
1400     return jPanelPcdFields;
1401 }
1402 /**
1403  * This method initializes jPanelPcdFieldsSecondRow
1404  *
1405  * @return javax.swing.JPanel
1406  */
1407 private JPanel getJPanelPcdFieldsSecondRow() {
1408     if (jPanelPcdFieldsSecondRow == null) {
1409         FlowLayout flowLayout2 = new FlowLayout();
1410         flowLayout2.setAlignment(java.awt.FlowLayout.LEFT);
1411         jLabelMaxDatumSize = new JLabel();
1412         jLabelMaxDatumSize.setText("Max Datum Size");
1413         jPanelPcdFieldsSecondRow = new JPanel();
1414         jPanelPcdFieldsSecondRow.setLayout(flowLayout2);
1415         jPanelPcdFieldsSecondRow.add(jLabelMaxDatumSize, null);
1416         jPanelPcdFieldsSecondRow.add(getJTextFieldMaxDatumSize(), null);
1417     }
1418     return jPanelPcdFieldsSecondRow;
1419 }
1420 /**
1421  * This method initializes jPanelPcdFieldsThirdRow
1422  *
1423  * @return javax.swing.JPanel
1424  */
1425 private JPanel getJPanelPcdFieldsThirdRow() {
1426     if (jPanelPcdFieldsThirdRow == null) {
1427         FlowLayout flowLayout3 = new FlowLayout();
1428         flowLayout3.setAlignment(java.awt.FlowLayout.LEFT);
1429         jLabelPcdDefaultValue = new JLabel();
1430         jLabelPcdDefaultValue.setText("Default Value");
1431         jLabelPcdDefaultValue.setPreferredSize(new java.awt.Dimension(91,16));
1432         jPanelPcdFieldsThirdRow = new JPanel();
1433         jPanelPcdFieldsThirdRow.setLayout(flowLayout3);
1434         jPanelPcdFieldsThirdRow.add(jLabelPcdDefaultValue, null);
1435         jPanelPcdFieldsThirdRow.add(getJTextFieldPcdDefault(), null);
1436         jPanelPcdFieldsThirdRow.add(getJComboBoxFeatureFlagValue(), null);
1437     }
1438     return jPanelPcdFieldsThirdRow;
1439 }
1440 /**
1441  * This method initializes jPanelPcdFieldsFirstRow
1442  *
1443  * @return javax.swing.JPanel
1444  */
1445 private JPanel getJPanelPcdFieldsFirstRow() {
1446     if (jPanelPcdFieldsFirstRow == null) {
1447         FlowLayout flowLayout1 = new FlowLayout();
1448         flowLayout1.setAlignment(java.awt.FlowLayout.LEFT);
1449         jLabelItemType = new JLabel();
1450         jLabelItemType.setText("Item Type");
1451         jLabelItemType.setPreferredSize(new java.awt.Dimension(91,16));
1452         jPanelPcdFieldsFirstRow = new JPanel();
1453         jPanelPcdFieldsFirstRow.setLayout(flowLayout1);
1454         jPanelPcdFieldsFirstRow.add(jLabelItemType, null);
1455         jPanelPcdFieldsFirstRow.add(getJComboBoxItemType(), null);
1456         jPanelPcdFieldsFirstRow.add(getJButtonUpdatePcd(), null);
1457     }
1458     return jPanelPcdFieldsFirstRow;
1459 }
1460 /**
1461  * This method initializes jComboBoxItemType
1462  *
1463  * @return javax.swing.JComboBox
1464  */
1465 private JComboBox getJComboBoxItemType() {
1466     if (jComboBoxItemType == null) {
1467         jComboBoxItemType = new JComboBox();
1468         jComboBoxItemType.setPreferredSize(new java.awt.Dimension(200,20));
1469         jComboBoxItemType.addItemListener(new java.awt.event.ItemListener() {
1470             public void itemStateChanged(java.awt.event.ItemEvent e) {
1471                 int row = jTablePcd.getSelectedRow();
1472                 if (row < 0 || jTablePcd.getValueAt(row, 2).equals(jComboBoxItemType.getSelectedItem())) {
1473                     return;
1474                 }
1475                 if (jComboBoxItemType.getItemCount() == 3) {
1476                     if (!jComboBoxItemType.getSelectedItem().equals("DYNAMIC")) {
1477                         pcdDynamicToNonDynamic(jTablePcd.getValueAt(row, 0)+"", jTablePcd.getValueAt(row, 1)+"");
1478                     }
1479                     else{
1480                         pcdNonDynamicToDynamic(jTablePcd.getValueAt(row, 0)+"", jTablePcd.getValueAt(row, 1)+"");
1481                     }
1482                 }
1483             }
1484         });
1485     }
1486     return jComboBoxItemType;
1487 }
1488
1489 private void pcdDynamicToNonDynamic(String cName, String tsGuid) {
1490     String[][] saa = new String[ffc.getDynamicPcdBuildDataCount()][5];
1491     ffc.getDynamicPcdBuildData(saa);
1492     String maxSize = "";
1493     String value = "";
1494     for (int i = 0; i < saa.length; ++i) {
1495         if (saa[i][0].equals(cName) && saa[i][2].equals(tsGuid)) {
1496             maxSize = saa[i][3];
1497             value = ffc.getDynamicPcdBuildDataValue(i);
1498             break;
1499         }
1500     }
1501
1502     ArrayList<String> al = ffc.getDynPcdMapValue(cName + " " + tsGuid);
1503     for (int i = 0; i < al.size(); ++i) {
1504         String[] s = al.get(i).split(" ");
1505         String mKey = s[0] + s[1] + s[2] + s[3];
1506         ffc.updatePcdData(mKey, cName, tsGuid, jComboBoxItemType.getSelectedItem()+"", maxSize, value);
1507         s[4] = jComboBoxItemType.getSelectedItem()+"";
1508         al.set(i, s[0]+" "+s[1]+" "+s[2]+" "+s[3]+" "+s[4]);
1509     }
1510
1511     ffc.removeDynamicPcdBuildData(cName, tsGuid);
1512 }
1513
1514 private void pcdNonDynamicToDynamic(String cName, String tsGuid) {
1515     ArrayList<String> al = ffc.getDynPcdMapValue(cName + " " + tsGuid);
1516     for (int i = 0; i < al.size(); ++i) {
1517         String[] s = al.get(i).split(" ");
1518         String mKey = s[0] + " " + s[1]+ " " + s[2] + " " + s[3];
1519         ffc.updatePcdData(mKey, cName, tsGuid, jComboBoxItemType.getSelectedItem()+"", jTextFieldMaxDatumSize.getText(), jTextFieldPcdDefault.isVisible() ? jTextFieldPcdDefault.getText() : jComboBoxFeatureFlagValue.getSelectedItem()+"");
1520         s[4] = jComboBoxItemType.getSelectedItem()+"";
1521         al.set(i, s[0]+" "+s[1]+" "+s[2]+" "+s[3]+" "+s[4]);
1522     }
1523     try{
1524         ffc.addDynamicPcdBuildData(cName, jTablePcd.getValueAt(jTablePcd.getSelectedRow(), 3), tsGuid, "DYNAMIC", jTablePcd.getValueAt(jTablePcd.getSelectedRow(), 5)+"", jTextFieldPcdDefault.isVisible() ? jTextFieldPcdDefault.getText() : jComboBoxFeatureFlagValue.getSelectedItem()+"");
1525     }
1526     catch(Exception e){
1527         JOptionPane.showMessageDialog(frame, "PCD value format: " + e.getMessage());
1528     }
1529 }
1530 /**
1531  * This method initializes jTextFieldMaxDatumSize
1532  *
1533  * @return javax.swing.JTextField
1534  */
1535 private JTextField getJTextFieldMaxDatumSize() {
1536     if (jTextFieldMaxDatumSize == null) {
1537         jTextFieldMaxDatumSize = new JTextField();
1538         jTextFieldMaxDatumSize.setPreferredSize(new java.awt.Dimension(200,20));
1539     }
1540     return jTextFieldMaxDatumSize;
1541 }
1542 /**
1543  * This method initializes jTextField4
1544  *
1545  * @return javax.swing.JTextField
1546  */
1547 private JTextField getJTextFieldPcdDefault() {
1548     if (jTextFieldPcdDefault == null) {
1549         jTextFieldPcdDefault = new JTextField();
1550         jTextFieldPcdDefault.setPreferredSize(new java.awt.Dimension(200,20));
1551     }
1552     return jTextFieldPcdDefault;
1553 }
1554 /**
1555  * This method initializes jButton6
1556  *
1557  * @return javax.swing.JButton
1558  */
1559 private JButton getJButtonUpdatePcd() {
1560     if (jButtonUpdatePcd == null) {
1561         jButtonUpdatePcd = new JButton();
1562         jButtonUpdatePcd.setPreferredSize(new java.awt.Dimension(150,20));
1563         jButtonUpdatePcd.setText("Update PCD Data");
1564         jButtonUpdatePcd.addActionListener(new java.awt.event.ActionListener() {
1565             public void actionPerformed(java.awt.event.ActionEvent e) {
1566                 int row = jTablePcd.getSelectedRow();
1567                 if (row < 0) {
1568                     return;
1569                 }
1570                 docConsole.setSaved(false);
1571                 model.setValueAt(jComboBoxItemType.getSelectedItem(), row, 2);
1572                 model.setValueAt(jTextFieldMaxDatumSize.getText(), row, 4);
1573                 model.setValueAt(jTextFieldPcdDefault.isVisible()? jTextFieldPcdDefault.getText():jComboBoxFeatureFlagValue.getSelectedItem(), row, 6);
1574                 ffc.updatePcdData(moduleKey, model.getValueAt(row, 0)+"", model.getValueAt(row, 1)+"", model.getValueAt(row, 2)+"", model.getValueAt(row, 4)+"", model.getValueAt(row, 6)+"");
1575             }
1576         });
1577     }
1578     return jButtonUpdatePcd;
1579 }
1580 /**
1581  * This method initializes jComboBoxFeatureFlagValue
1582  *
1583  * @return javax.swing.JComboBox
1584  */
1585 private JComboBox getJComboBoxFeatureFlagValue() {
1586     if (jComboBoxFeatureFlagValue == null) {
1587         jComboBoxFeatureFlagValue = new JComboBox();
1588         jComboBoxFeatureFlagValue.setPreferredSize(new java.awt.Dimension(100,20));
1589         jComboBoxFeatureFlagValue.setVisible(false);
1590         jComboBoxFeatureFlagValue.addItem("true");
1591         jComboBoxFeatureFlagValue.addItem("false");
1592     }
1593     return jComboBoxFeatureFlagValue;
1594 }
1595
1596
1597 }  //  @jve:decl-index=0:visual-constraint="10,10"
1598
1599 class PartialEditableTableModel extends DefaultTableModel {
1600     /**
1601      *
1602      */
1603     private static final long serialVersionUID = 1L;
1604
1605     public boolean isCellEditable(int row, int col) {
1606         switch (col){
1607         case 2:
1608             return false;
1609         default:
1610             return false;
1611         }
1612
1613     }
1614 }
1615
1616 class LibraryTableModel extends DefaultTableModel {
1617     /**
1618      *
1619      */
1620     private static final long serialVersionUID = 1L;
1621
1622     public boolean isCellEditable(int row, int col) {
1623         return false;
1624     }
1625 }