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

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