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