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