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