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