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