Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/platform/ui/FpdModuleSA.java

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