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

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