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