package org.tianocore.frameworkwizard.platform.ui;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;

import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JDialog;
import javax.swing.JTabbedPane;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.JSplitPane;
import javax.swing.JButton;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
import javax.swing.table.TableModel;

import org.tianocore.frameworkwizard.FrameworkWizardUI;
import org.tianocore.frameworkwizard.common.DataValidation;
import org.tianocore.frameworkwizard.common.GlobalData;
import org.tianocore.frameworkwizard.common.IDefaultTableModel;
import org.tianocore.frameworkwizard.common.Identifications.OpeningPlatformType;
import org.tianocore.frameworkwizard.platform.ui.global.LibraryClassDescriptor;
import org.tianocore.frameworkwizard.platform.ui.global.WorkspaceProfile;
import org.tianocore.frameworkwizard.platform.ui.global.SurfaceAreaQuery;
import org.tianocore.frameworkwizard.module.Identifications.ModuleIdentification;
import org.tianocore.frameworkwizard.packaging.PackageIdentification;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.ListIterator;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;

import javax.swing.JTextField;
import java.awt.GridLayout;
import javax.swing.JComboBox;

public class FpdModuleSA extends JDialog implements ActionListener {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private JPanel jContentPane = null;
    private JTabbedPane jTabbedPane = null;
    private JPanel jPanelPcd = null;
    private JPanel jPanelLibrary = null;
    private JLabel jLabelPcdData = null;
    private JScrollPane jScrollPaneTablePcd = null;
    private JTable jTablePcd = null;
    private JPanel jPanelPcdSouth = null;
    private JScrollPane jScrollPanePcdHelp = null;
    private JTextArea jTextAreaPcdHelp = null;
    private JPanel jPanelContentPaneSouth = null;
    private JSplitPane jSplitPane = null;
    private JPanel jPanelLibraryLeft = null;
    private JPanel jPanelLibraryRight = null;
    private JLabel jLabelLibClass = null;
    private JLabel jLabelQualifiedInstance = null;
    private JScrollPane jScrollPaneSelectedInstances = null;
    private JTable jTableSelectedInstances = null;
    private JScrollPane jScrollPaneLibClass = null;
    private JTable jTableLibClass = null;
    private JScrollPane jScrollPaneQualifiedInstance = null;
    private JTable jTableLibInstances = null;
    private JPanel jPanelLibrarySouth = null;
    private JPanel jPanelLibraryCenter = null;
    private JScrollPane jScrollPaneInstanceHelp = null;
    private JTextArea jTextAreaInstanceHelp = null;
    private JLabel jLabelSelectedInstances = null;
    private JLabel jLabelInstanceHelp = null;
    private JButton jButtonAdd = null;
    private JButton jButtonDeleteInstance = null;
    private JLabel jLabelPcdHelp = null;
    private JButton jButtonOk = null;
    private JButton jButtonCancel = null;
    private IDefaultTableModel model = null;
    private IDefaultTableModel selectedInstancesTableModel = null;
    private IDefaultTableModel libClassTableModel = null;
    private IDefaultTableModel libInstanceTableModel = null;
    private DefaultTableModel optionsTableModel = null;
    private FpdFileContents ffc = null;
    private String moduleKey = null;
    private ModuleIdentification moduleId = null;
    private HashMap<LibraryClassDescriptor, ArrayList<String>> classInstanceMap = null;
    //
    // map of <{libName, supArch, supMod}, list of Module information>
    //
    private HashMap<LibraryClassDescriptor, ArrayList<String>> classConsumed = null;
    private HashMap<LibraryClassDescriptor, ArrayList<String>> classProduced = null;
    
    private JPanel jPanelModuleSaOpts = null;
    private JLabel jLabelFvBinding = null;
    private JTextField jTextFieldFvBinding = null;
    private JLabel jLabelFfsFileGuid = null;
    private JTextField jTextFieldFileGuid = null;
    private JLabel jLabelFfsFormatKey = null;
    private JTextField jTextFieldFfsKey = null;
    private JScrollPane jScrollPaneModuleSaOptions = null;
    private JTable jTableModuleSaOptions = null;
    private JButton jButtonNew = null;
    private JButton jButtonDeleteOption = null;
    private JPanel jPanelPcdFields = null;
    private JPanel jPanelPcdFieldsSecondRow = null;
    private JPanel jPanelPcdFieldsThirdRow = null;
    private JPanel jPanelPcdFieldsFirstRow = null;
    private JLabel jLabelItemType = null;
    private JComboBox jComboBoxItemType = null;
    private JLabel jLabelMaxDatumSize = null;
    private JTextField jTextFieldMaxDatumSize = null;
    private JLabel jLabelPcdDefaultValue = null;
    private JTextField jTextFieldPcdDefault = null;
    private JButton jButtonUpdatePcd = null;
    private JComboBox jComboBoxFeatureFlagValue = null;
    private OpeningPlatformType docConsole = null;
    private JPanel jPanelCustomToolChain = null;
    private JPanel jPanelToolchainS = null;
    private JPanel jPanelLibraryCenterN = null;
    private JPanel jPanelLibraryCenterC = null;  //  @jve:decl-index=0:visual-constraint="20,224"
    
    private final int buildTargetWidth = 150;
    private final int toolChainFamilyWidth = 150;
    private final int supportArchWidth = 150;
    private final int toolCmdCodeWidth = 200;
    private final int tagNameWidth = 150;
    private final int argWidth = 400;
    
    /**
     * This is the default constructor
     */
    public FpdModuleSA() {
        super(FrameworkWizardUI.getInstance());
        initialize();
    }
    public FpdModuleSA(FpdFileContents ffc) {
        this();
        this.ffc = ffc;
    }
    
    public void setKey(String k, int i, OpeningPlatformType dc){
        this.moduleKey = k;
        this.docConsole = dc;
        classInstanceMap = null;
        classProduced = null;
        classConsumed = null;
        int tabIndex = jTabbedPane.indexOfTab("FV Info");
        jTabbedPane.setSelectedIndex(tabIndex);
        initFvInfo(moduleKey);
        initPcdBuildDefinition(moduleKey);
        moduleId = WorkspaceProfile.getModuleId(moduleKey);
        if (moduleId == null) {
            return;
        }
        tabIndex = jTabbedPane.indexOfTab("Libraries");
        if (moduleId.isLibrary()) {
            jTabbedPane.setEnabledAt(tabIndex, false);
        }
        else {
            jTabbedPane.setEnabledAt(tabIndex, true);
        }
    }

    /**
      init will be called each time FpdModuleSA object is to be shown.
      @param key Module information.
     **/
    public void initPcdBuildDefinition(String key) {
        //
        // display pcd for key.
        //
        model.setRowCount(0);
        jTextAreaPcdHelp.setText("");
        jComboBoxItemType.setSelectedIndex(-1);
        jTextFieldMaxDatumSize.setText("");
        jTextFieldPcdDefault.setText("");
        int pcdCount = ffc.getPcdDataCount(key);
        if (pcdCount != 0) {
            String[][] saa = new String[pcdCount][7];
            ffc.getPcdData(key, saa);
            for (int j = 0; j < saa.length; ++j) {
                model.addRow(saa[j]);
            }
        }
    }
    
    public void initLibraries(String key) {
        libClassTableModel.setRowCount(0);
        libInstanceTableModel.setRowCount(0);
        selectedInstancesTableModel.setRowCount(0);
        Vector<String> errorMsg = new Vector<String>();
        Vector<ModuleIdentification> newInstances = new Vector<ModuleIdentification>();
        
        addConsumedClassFromModule (key);
        addProducedClassFromModule (key);
        
        int instanceCount = ffc.getLibraryInstancesCount(key);
        if (instanceCount != 0) {
            String[][] saa = new String[instanceCount][5];
            ffc.getLibraryInstances(key, saa);
            for (int i = 0; i < saa.length; ++i) {
                String libInstanceKey = saa[i][1] + " " + saa[i][2] + " " + saa[i][3] + " " + saa[i][4];
                ModuleIdentification mi = WorkspaceProfile.getModuleId(libInstanceKey);
                if (mi != null) {
                    //
                    // ToDo: verify this instance first.
                    //
                    saa[i][0] = mi.getName();
                    saa[i][2] = mi.getVersion();
                    saa[i][4] = mi.getPackageId().getVersion();
                    //
                    // re-evaluate lib instance usage when adding a already-selected lib instance.
                    //
                    addConsumedClassFromModule (libInstanceKey);
                    addProducedClassFromModule (libInstanceKey);
                    selectedInstancesTableModel.addRow(saa[i]);
                }
            }
        }
        
        Set<LibraryClassDescriptor> sLcd = this.classConsumed.keySet();
        Iterator<LibraryClassDescriptor> iter = sLcd.iterator(); 
        Stack<LibraryClassDescriptor> lcdStack = new Stack<LibraryClassDescriptor>();
        while (iter.hasNext()) {
            LibraryClassDescriptor lcd = iter.next();
            if (this.classConsumed.get(lcd) == null || this.classConsumed.get(lcd).size() == 0) {
                continue;
            }
            if (isBoundedClass(lcd, errorMsg)) {
                continue;
            }
            
            if (!lcdStack.contains(lcd)) {
                lcdStack.push(lcd);
            }
        }
        
        try {
            resolveLibraryInstances(lcdStack, true, errorMsg, newInstances);
        } catch (Exception e) {
            String exceptionMsg = e.getCause() + " " + e.getMessage();
            if (!errorMsg.contains(exceptionMsg)) {
                JOptionPane.showMessageDialog(FrameworkWizardUI.getInstance(), e.getCause() + " " + e.getMessage());
            }
        }
        
        String newInstancesAddedMsg = "Library instance automatically added to this module :\n";
        for (int i = 0; i < newInstances.size(); ++i) {
            ModuleIdentification libMi = newInstances.get(i);
            newInstancesAddedMsg += libMi.getName();
            newInstancesAddedMsg += " ";
        }
        if (newInstances.size() > 0) {
            JOptionPane.showMessageDialog(FrameworkWizardUI.getInstance(), newInstancesAddedMsg);
        }
        
        showClassToResolved();
        
        if (errorMsg.size() > 0) {
            String errors = "";
            for (int i = 0; i < errorMsg.size(); ++i) {
                errors += " " + errorMsg.get(i) + "\n";
            }
            JOptionPane.showMessageDialog(FrameworkWizardUI.getInstance(), errors);
        }
    }
    
    public void initFvInfo (String key) {
        //
        // display module SA options
        //
        jTextFieldFvBinding.setText("");
        String fvBinding = ffc.getFvBinding(key);
        if (fvBinding != null) {
            jTextFieldFvBinding.setText(fvBinding);
        }
        jTextFieldFileGuid.setText("");
        String fileGuid = ffc.getFfsFileNameGuid(key);
        if (fileGuid != null) {
            jTextFieldFileGuid.setText(fileGuid);
        }
        jTextFieldFfsKey.setText("");
        String ffsKey = ffc.getFfsFormatKey(key);
        if (ffsKey != null) {
            jTextFieldFfsKey.setText(ffsKey);
        }
    }
    
    public void initToolChainOptions(String key) {
        
        optionsTableModel.setRowCount(0);
        String[][] saa = new String[ffc.getModuleSAOptionsCount(key)][6];
        ffc.getModuleSAOptions(key, saa);
        for (int i = 0; i < saa.length; ++i) {
            optionsTableModel.addRow(saa[i]);
        }
    }
    
    private void filterClassConsumedByArch (Vector<LibraryClassDescriptor> v) {
        String[] moduleInfo = moduleKey.split(" ");
        Vector<String> vModuleArchs = new Vector<String>();
        //
        // Skip guid, version information, get archs to check.
        //
        for (int i = 4; i < moduleInfo.length; ++i) {
            vModuleArchs.add(moduleInfo[i]);
        }
        //
        // if module will be built on all platforms, no filter needed for lib classes.
        //
        if (vModuleArchs.size() == 0) {
            return;
        }
        
        Iterator<LibraryClassDescriptor> iter = v.iterator();
        while (iter.hasNext()) {
            LibraryClassDescriptor libInfo = iter.next();

            Vector<String> vSupArchs = libInfo.getVectorFromString(libInfo.supArchs);
            
            if (vSupArchs.size() == 0 || (vSupArchs.size() == 1 && vSupArchs.get(0).equalsIgnoreCase(""))) {
                //
                // update lib info to module archs only.
                //
                libInfo.supArchs = "";
                for (int i = 0; i < vModuleArchs.size(); ++i) {
                    libInfo.supArchs += vModuleArchs.get(i);
                    libInfo.supArchs += " ";
                }
                libInfo.supArchs.trim();
                continue;
            }
            //
            // only retain those lib class used by module archs.
            //
            vSupArchs.retainAll(vModuleArchs);
            if (vSupArchs.size() > 0) {
                //
                // update lib info to reflect which kind of arch need to select instance.
                //
                libInfo.supArchs = "";
                for (int i = 0; i < vSupArchs.size(); ++i) {
                    libInfo.supArchs += vSupArchs.get(i);
                    libInfo.supArchs += " ";
                }
                libInfo.supArchs.trim();
                continue;
            }
            //
            // remove this lib definition if it supports no archs module will be built under.
            //
            iter.remove();
        }
    }
    
    private void addProducedClassFromModule (String key) {
        ModuleIdentification mi = WorkspaceProfile.getModuleId(key);
        Vector<LibraryClassDescriptor> vClassProduced = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED", mi);
        if (this.classProduced == null) {
            this.classProduced = new HashMap<LibraryClassDescriptor, ArrayList<String>>();
        }
        for (int i = 0; i < vClassProduced.size(); ++i) {
            ArrayList<String> producedBy = this.classProduced.get(vClassProduced.get(i));
            if (producedBy == null) {
                producedBy = new ArrayList<String>();
            }
            //
            // class already produced by previous module (lib instance).
            /*
            if (producedBy.size() == 1) {
                String instanceKey = producedBy.get(0);
                ModuleIdentification libMi = WorkspaceProfile.getModuleId(instanceKey);
                throw new MultipleInstanceException (vClassProduced.get(i).className, libMi.getName(), mi.getName());
            }
            Iterator<LibraryClassDescriptor> lcdi = this.classProduced.keySet().iterator();
            while (lcdi.hasNext()) {
                LibraryClassDescriptor lcd = lcdi.next();
                if (vClassProduced.get(i).hasInterSectionWith(lcd)) {
                    ArrayList<String> alreadyProducedBy = this.classProduced.get(lcd);
                    String instanceKey = alreadyProducedBy.get(0);
                    ModuleIdentification libMi = WorkspaceProfile.getModuleId(instanceKey);
                    throw new MultipleInstanceException (vClassProduced.get(i).className, libMi.getName(), mi.getName());
                }
            }
            */
            // normal case.
            //
            producedBy.add(key);
            this.classProduced.put(vClassProduced.get(i), producedBy);
            
        }
    }
    
    private Vector<LibraryClassDescriptor> addConsumedClassFromModule (String key) {
        ModuleIdentification mi = WorkspaceProfile.getModuleId(key);
//        PackageIdentification[] depPkgList = null;
        
        //
        // Get dependency pkg list into which we will search lib instances.
        //
        //depPkgList = SurfaceAreaQuery.getDependencePkg(null, mi);
        //
        // Get the lib class consumed, produced by this module itself.
        //
        Vector<LibraryClassDescriptor> vClassConsumed = SurfaceAreaQuery.getLibraryClasses("ALWAYS_CONSUMED", mi);
        for (int i = 0; i < vClassConsumed.size(); ++i) {
            vClassConsumed.get(i).supModTypes = WorkspaceProfile.getModuleType(moduleId);
        }
        filterClassConsumedByArch(vClassConsumed);
        if (this.classConsumed == null) {
            this.classConsumed = new HashMap<LibraryClassDescriptor, ArrayList<String>>();
        }

        for (int i = 0; i < vClassConsumed.size(); ++i) {
            ArrayList<String> consumedBy = this.classConsumed.get(vClassConsumed.get(i));
            if (consumedBy == null) {
                consumedBy = new ArrayList<String>();
            }
            consumedBy.add(key);
            this.classConsumed.put(vClassConsumed.get(i), consumedBy);
        }

        return vClassConsumed;
    }
    
    private void resolveLibraryInstances(Stack<LibraryClassDescriptor> lcdStack, boolean autoSelectSingleInstance, Vector<String> errorMsg, Vector<ModuleIdentification> newInstances) throws MultipleInstanceException, NoInstanceException{
        
        if (classInstanceMap == null) {
            classInstanceMap = new HashMap<LibraryClassDescriptor, ArrayList<String>>();
        }        
        while (!lcdStack.empty()) {
            LibraryClassDescriptor cls = lcdStack.pop();
            if (isBoundedClass(cls, errorMsg)) {
                continue;
            }
            ArrayList<String> instances = getInstancesForClass(cls, null);
            if (instances.size() == 0) {
//                throw new NoInstanceException (cls.className);
                String exceptionMsg = new NoInstanceException (cls.className).getMessage();
                if (!errorMsg.contains(exceptionMsg)) {
                    errorMsg.add(exceptionMsg);    
                }
                
            }
            classInstanceMap.put(cls, instances);
            if (instances.size() == 1 && autoSelectSingleInstance) {
                String instanceInfo = instances.get(0);
                ModuleIdentification libMi = WorkspaceProfile.getModuleId(instanceInfo);
                try {
                    Object[] row = {libMi.getName(), libMi.getGuid(), libMi.getVersion(), 
                                    libMi.getPackageId().getGuid(), libMi.getPackageId().getVersion()};
                    if (!ffc.instanceExistsInModuleSA(moduleKey, row[1]+"", row[2]+"", row[3]+"", row[4]+"")) {
                        addLibInstance(libMi);
                        newInstances.add(libMi);
                        docConsole.setSaved(false);
                        selectedInstancesTableModel.addRow(row);
                        addProducedClassFromModule (instanceInfo);
                        Vector<LibraryClassDescriptor> vLcd = addConsumedClassFromModule(instanceInfo);
                        for (int i = 0; i < vLcd.size(); ++i) {
                            LibraryClassDescriptor lcd = vLcd.get(i);
                            if (!lcdStack.contains(lcd)) {
                                lcdStack.push(lcd);
                            }
                        }
                    }
                }
                catch (Exception e) {
                    if (!errorMsg.contains(e.getMessage())) {
                        errorMsg.add(e.getMessage());
                    }
                }
            }
        }
    }
//            

    /**Search classProduced map to see if this class has been produced by some instance (module).
     * @param cls
     * @return
     */
    private boolean isBoundedClass (LibraryClassDescriptor cls, Vector<String> errorMsg) {
//        if (this.classProduced.containsKey(cls)) {
//            return true;
//        }
        Iterator<LibraryClassDescriptor> lcdi = this.classProduced.keySet().iterator();
        while (lcdi.hasNext()) {
            LibraryClassDescriptor lcd = lcdi.next();
            if (cls.className.equals(lcd.className)) {
                if (cls.isSubSetByArchs(lcd) && cls.isSubSetByModTypes(lcd)) {
                    return true;
                }
                else {
                    ArrayList<String> producedBy = this.classProduced.get(lcd);
                    String instancesName = "";
                    for (int i = 0; i < producedBy.size(); ++i) {
                        ModuleIdentification mi = WorkspaceProfile.getModuleId(producedBy.get(i));
                        instancesName += mi.getName();
                        instancesName += " ";
                    }
                    String msg = new ImproperInstanceException(lcd.className, instancesName, lcd.supArchs, lcd.supModTypes).getMessage();
                    if (!errorMsg.contains(msg)) {
                        errorMsg.add(msg);
                    }
                }
            }
        }
        
        return false;
    }
    
    private ArrayList<String> getInstancesForClass(LibraryClassDescriptor cls, PackageIdentification[] depPkgList){
        ArrayList<String> al = new ArrayList<String>();
        
//        for (int i = 0; i < depPkgList.length; ++i) {
            Iterator ismi = GlobalData.vModuleList.iterator();
            while(ismi.hasNext()) {
                ModuleIdentification mi = (ModuleIdentification)ismi.next();
//                if (!mi.getPackageId().getGuid().equalsIgnoreCase(depPkgList[i].getGuid())) {
//                    continue;
//                }
                Vector<LibraryClassDescriptor> clsProduced = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED", mi);
                
                boolean isPotential = false;
                Iterator<LibraryClassDescriptor> lcdi = clsProduced.iterator();
                while (lcdi.hasNext()) {
                    LibraryClassDescriptor lcd = lcdi.next();
                    if (cls.isSubSetByArchs(lcd) && cls.isSubSetByModTypes(lcd)){
                        isPotential = true;
                    }
                    
                    if (isPotential && hasBeenProduced(lcd)) {
                        isPotential = false;
                        break;
                    }
                }
                if (isPotential) {
                    al.add(mi.getGuid() + " " + mi.getVersion() + " " + 
                           mi.getPackageId().getGuid() + " " + mi.getPackageId().getVersion());
                }
            }
//        }
        
        return al;
    }
    
    private boolean hasBeenProduced (LibraryClassDescriptor cls) {
        Iterator<LibraryClassDescriptor> lcdi = this.classProduced.keySet().iterator();
        while (lcdi.hasNext()) {
            LibraryClassDescriptor lcd = lcdi.next();
            if (cls.isSubSetByArchs(lcd) && cls.isSubSetByModTypes(lcd)) {
                return true;
            }
        }
        return false;
    }
    
    private ArrayList<String> getConsumedBy (String className) {
        Iterator<LibraryClassDescriptor> lcdi = this.classConsumed.keySet().iterator();
        while (lcdi.hasNext()) {
            LibraryClassDescriptor lcd = lcdi.next();
            if ((lcd.className != null) && lcd.className.equals(className)) {
                return this.classConsumed.get(lcd);
            }
        }
        return null;
    }
    
    private ArrayList<String> getProducedBy (String className) {
        Iterator<LibraryClassDescriptor> lcdi = this.classProduced.keySet().iterator();
        while (lcdi.hasNext()) {
            LibraryClassDescriptor lcd = lcdi.next();
            if ((lcd.className != null) && lcd.className.equals(className)) {
                return this.classProduced.get(lcd);
            }
        }
        return null;
    }
    //
    // Get class name list related with instanceKey from HashMap m<LibraryClass, ArrayList<instanceKey>>.
    //
    private ArrayList<String> getLibraryClassList (String instanceKey, HashMap<LibraryClassDescriptor, ArrayList<String>> m) {
        ArrayList<String> libraryClass = new ArrayList<String>();
        Iterator<LibraryClassDescriptor> lcdi = m.keySet().iterator();
        while (lcdi.hasNext()) {
            LibraryClassDescriptor lcd = lcdi.next();
            if ((m.get(lcd) != null) && m.get(lcd).contains(instanceKey)) {
                libraryClass.add(lcd.className);
            }
        }
        return libraryClass;
    }
    
    private void removeInstance(String key) {
        ModuleIdentification mi = WorkspaceProfile.getModuleId(key); 
        //
        // remove pcd information of instance from current ModuleSA
        // Note that Pcd data SHOULD be removed prior to library instance
        // because Multi-Sourced PCD could not be removed, if we remove library instance first,
        // it will impact the judgement of whether a PCD entry is Multi-Sourced.
        //
        ffc.removePcdData(moduleKey, mi);
        ffc.removeLibraryInstance(moduleKey, key);
        //
        // remove class produced by this instance and add back these produced class to be bound.
        //
        Vector<LibraryClassDescriptor> clsProduced = getClassProduced(mi);
        for (int i = 0; i < clsProduced.size(); ++i) {
            
            classProduced.remove(clsProduced.get(i));
        }
        //
        // remove class consumed by this instance. we do not need to bound it now.
        //
        String[] clsConsumed = getClassConsumed(mi);
        for (int i = 0; i < clsConsumed.length; ++i) {
            ArrayList<String> al = getConsumedBy (clsConsumed[i]);
            
            if (al == null ) {
                continue;
            }
            al.remove(key);
            if (al.size() == 0) {
                ArrayList<String> from = getProducedBy (clsConsumed[i]);
                if (from == null) {
                    continue;
                }
                boolean noUse = true;
                for (int j = 0; j < from.size(); ++j) {
                    ArrayList<String> libClasses = getLibraryClassList(from.get(j), classProduced);
                    for (int k = 0; k < libClasses.size(); ++k) {
                        if (getConsumedBy (libClasses.get(k)) != null && getConsumedBy (libClasses.get(k)).size() > 0) {
                            noUse = false;
                        }
                    }
                    if (noUse) {
                        removeInstance(from.get(j));
                    }
                    noUse = true;
                }
            }
        }
        
    }
    
    
    private Vector<LibraryClassDescriptor> getClassProduced(ModuleIdentification mi){
        
        Vector<LibraryClassDescriptor> clsProduced = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED", mi);
        return clsProduced;
//        String[] sClassProduced = new String[clsProduced.size()];
//        for (int i = 0; i < clsProduced.size(); ++i) {
//            sClassProduced[i] = clsProduced.get(i).className;
//        }
//        return sClassProduced;
    }
    
    private String[] getClassConsumed(ModuleIdentification mi){
        
        Vector<LibraryClassDescriptor> clsConsumed = SurfaceAreaQuery.getLibraryClasses("ALWAYS_CONSUMED", mi);
        String[] sClassConsumed = new String[clsConsumed.size()];
        for (int i = 0; i < clsConsumed.size(); ++i) {
            sClassConsumed[i] = clsConsumed.get(i).className;
        }
        return sClassConsumed;
    }
    
    private void showClassToResolved(){
        Vector<String> errorMsg = new Vector<String>();
        libClassTableModel.setRowCount(0);
        libInstanceTableModel.setRowCount(0);
        if (classConsumed == null || classConsumed.size() == 0) {
            return;
        }

        Iterator<LibraryClassDescriptor> li = classConsumed.keySet().iterator();
        while(li.hasNext()){
            LibraryClassDescriptor lcd = li.next();
            if (classConsumed.get(lcd) == null || classConsumed.get(lcd).size() == 0) {
                continue;
            }
            
            if (!isBoundedClass(lcd, errorMsg)){
     
                String[] s = { lcd.className, lcd.supArchs, lcd.supModTypes };
                libClassTableModel.addRow(s);
            }
        }

        if (errorMsg.size() > 0) {
            String errors = "";
            for (int i = 0; i < errorMsg.size(); ++i) {
                errors += " " + errorMsg.get(i) + "\n";
            }
            JOptionPane.showMessageDialog(FrameworkWizardUI.getInstance(), errors);
        }
    }
    
    private String getModuleArch () {
    	String arch = "";
    	String[] moduleInfo = moduleKey.split(" ");
    	for (int i = 4; i < moduleInfo.length; ++i) {
    		arch += moduleInfo[i];
    		arch += " ";
    	}
    	return arch.trim();
    }
    private void addLibInstance (ModuleIdentification libMi) throws Exception{
        
        //
        // Add pcd information of selected instance to current moduleSA
        //
        ffc.addFrameworkModulesPcdBuildDefs(libMi, getModuleArch(), ffc.getModuleSA(moduleKey));
        
        ffc.genLibraryInstance(libMi, moduleKey);
    }
    /**
     * This method initializes this
     * 
     * @return void
     */
    private void initialize() {
        this.setSize(877, 555);
        this.setResizable(false);
        this.centerWindow();
        this.setModal(true);
        this.setTitle("Module Settings");
        this.setContentPane(getJContentPane());
    }

    /**
     * This method initializes jContentPane
     * 
     * @return javax.swing.JPanel
     */
    private JPanel getJContentPane() {
        if (jContentPane == null) {
            jContentPane = new JPanel();
            jContentPane.setLayout(new BorderLayout());
            jContentPane.add(getJTabbedPane(), java.awt.BorderLayout.CENTER);
            jContentPane.add(getJPanelContentPaneSouth(), java.awt.BorderLayout.SOUTH);
        }
        return jContentPane;
    }

    /**
     * This method initializes jTabbedPane	
     * 	
     * @return javax.swing.JTabbedPane	
     */
    private JTabbedPane getJTabbedPane() {
        if (jTabbedPane == null) {
            jTabbedPane = new JTabbedPane();
            jTabbedPane.addTab("PCD Build Definition", null, getJPanelPcd(), null);
            jTabbedPane.addTab("Libraries", null, getJPanelLibrary(), null);
            jTabbedPane.addTab("FV Info", null, getJPanelModuleSaOpts(), null);
            jTabbedPane.addTab("Custom Toolchain", null, getJPanelCustomToolChain(), null);
            
        }
        return jTabbedPane;
    }

    /**
     * This method initializes jPanelPcd
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelPcd() {
        if (jPanelPcd == null) {
            jLabelPcdData = new JLabel();
            jLabelPcdData.setText(" PCD Data");
            jPanelPcd = new JPanel();
            jPanelPcd.setLayout(new BorderLayout());
            jPanelPcd.add(jLabelPcdData, java.awt.BorderLayout.NORTH);
            jPanelPcd.add(getJScrollPaneTablePcd(), java.awt.BorderLayout.CENTER);
            jPanelPcd.add(getJPanelPcdSouth(), java.awt.BorderLayout.SOUTH);
            jPanelPcd.addComponentListener(new java.awt.event.ComponentAdapter() {
                public void componentShown(java.awt.event.ComponentEvent e) {
                    initPcdBuildDefinition(moduleKey);
                }
            });
            
        }
        return jPanelPcd;
    }

    /**
     * This method initializes jPanelLibrary
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelLibrary() {
        if (jPanelLibrary == null) {
            jPanelLibrary = new JPanel();
            jPanelLibrary.setLayout(new BorderLayout());
            jPanelLibrary.add(getJSplitPane(), java.awt.BorderLayout.NORTH);
            jPanelLibrary.add(getJPanelLibrarySouth(), java.awt.BorderLayout.SOUTH);
            jPanelLibrary.add(getJPanelLibraryCenter(), java.awt.BorderLayout.CENTER);
            jPanelLibrary.addComponentListener(new java.awt.event.ComponentAdapter() {
                public void componentShown(java.awt.event.ComponentEvent e) {
                    initLibraries(moduleKey);
                }
            });
        }
        return jPanelLibrary;
    }

    /**
     * This method initializes jScrollPaneTablePcd
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneTablePcd() {
        if (jScrollPaneTablePcd == null) {
            jScrollPaneTablePcd = new JScrollPane();
            jScrollPaneTablePcd.setViewportView(getJTablePcd());
        }
        return jScrollPaneTablePcd;
    }

    /**
     * This method initializes jTable	
     * 	
     * @return javax.swing.JTable	
     */
    private JTable getJTablePcd() {
        if (jTablePcd == null) {
            model = new IDefaultTableModel();
            jTablePcd = new JTable(model);
            jTablePcd.setRowHeight(20);
            jTablePcd.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_ALL_COLUMNS);
            model.addColumn("CName");
            model.addColumn("TokenSpaceGUID");
            model.addColumn("ItemType");
            model.addColumn("Token");
            model.addColumn("MaxDatumSize");
            model.addColumn("DataType");
            model.addColumn("DefaultValue");
            
            jTablePcd.getColumnModel().getColumn(0).setMinWidth(250);
            
            TableColumn tokenColumn = jTablePcd.getColumnModel().getColumn(3);
            jTablePcd.removeColumn(tokenColumn);
                        
            jTablePcd.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            jTablePcd.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
                public void valueChanged(ListSelectionEvent e) {
                    
                    if (e.getValueIsAdjusting()){
                        return;
                    }
                    ListSelectionModel lsm = (ListSelectionModel)e.getSource();
                    if (lsm.isSelectionEmpty()) {
                        return;
                    }
                    else{
                        int selectedRow = lsm.getMinSelectionIndex();
                        String cName = model.getValueAt(selectedRow, 0)+"";
                        String tsGuid = model.getValueAt(selectedRow, 1)+"";
                        String itemType = model.getValueAt(selectedRow, 2)+"";
                        //
                        // array for pcd related information: helpText, itemType, moduleType.
                        //
                        String[] pcdInfo = {"", "", ""};
                        Vector<String> validPcdTypes = new Vector<String>();
                        getPcdInfo(moduleKey, cName, tsGuid, pcdInfo, validPcdTypes);
                        jTextAreaPcdHelp.setText(pcdInfo[0]);
                        initComboBox(pcdInfo[1], pcdInfo[2], validPcdTypes);
                        jComboBoxItemType.setSelectedItem(itemType);
                        jTextFieldMaxDatumSize.setEnabled(true);
                        jTextFieldMaxDatumSize.setVisible(true);
                        jTextFieldMaxDatumSize.setText(model.getValueAt(selectedRow, 4)+"");
                        jTextFieldPcdDefault.setEnabled(true);
                        jTextFieldPcdDefault.setText(model.getValueAt(selectedRow, 6)+"");
                        if ((model.getValueAt(selectedRow, 5) != null) && model.getValueAt(selectedRow, 5).equals("VOID*")) {
                            if (pcdInfo[1].equals("FEATURE_FLAG")) {
                                jTextFieldMaxDatumSize.setVisible(false);
                            }
                            else if (pcdInfo[1].equals("FIXED_AT_BUILD")) {
                                try{
                                    jTextFieldMaxDatumSize.setEnabled(false);
                                    jTextFieldMaxDatumSize.setText(ffc.setMaxSizeForPointer(model.getValueAt(selectedRow, 6)+"")+"");
                                }
                                catch(Exception except){
                                    JOptionPane.showMessageDialog(FpdModuleSA.this, "Unacceptable PCD Value: " + except.getMessage());
                                }
                            }
                            else{
                                jTextFieldMaxDatumSize.setText(model.getValueAt(selectedRow, 4)+"");
                            }
                        }
                        else {
                            jTextFieldMaxDatumSize.setEnabled(false);
                        }
                        
                        if (!model.getValueAt(selectedRow, 2).equals("DYNAMIC") && !model.getValueAt(selectedRow, 2).equals("DYNAMIC_EX")) {
                            jTextFieldPcdDefault.setText(model.getValueAt(selectedRow, 6)+"");
                            if (model.getValueAt(selectedRow, 2).equals("FEATURE_FLAG")){
                                jTextFieldPcdDefault.setVisible(false);
                                jComboBoxFeatureFlagValue.setVisible(true);
                                jComboBoxFeatureFlagValue.setSelectedItem(model.getValueAt(selectedRow, 6)+"");
                            }
                            else{
                                jTextFieldPcdDefault.setVisible(true);
                                jTextFieldPcdDefault.setEnabled(true);
                                jComboBoxFeatureFlagValue.setVisible(false);
                            }
                        }
                        else{
                            jTextFieldPcdDefault.setEnabled(false);
                        }
                    }
                    
                    
                }
            });
            
        }
        return jTablePcd;
    }
    
    private void initComboBox(String originalType, String mType, Vector<String> validPcdTypes) {
        jComboBoxItemType.removeAllItems();

        if (originalType.equals("DYNAMIC")) {
            for (int i = 0; i < validPcdTypes.size(); ++i) {
                jComboBoxItemType.addItem(validPcdTypes.get(i));
            }
        }
        else {
            jComboBoxItemType.addItem(originalType);
        }
    }
    
    /**
     * @param cName
     * @param tsGuid
     * @param sa sa[0]: HelpText; sa[1]: itemType in Msa; sa[2]: isBinary;
     */
    private void getPcdInfo(String moduleKey, String cName, String tsGuid, String[] sa, Vector<String> validPcdTypes) {
        String[][] saa = new String[ffc.getLibraryInstancesCount(moduleKey)][5];
        ffc.getLibraryInstances(moduleKey, saa);
        
        try{
            if (ffc.getPcdBuildDataInfo(WorkspaceProfile.getModuleId(moduleKey), cName, tsGuid, sa, validPcdTypes)) {
                return;
            }
            for (int j = 0; j < saa.length; ++j) {
                if (ffc.getPcdBuildDataInfo(WorkspaceProfile.getModuleId(saa[j][1] + " " + saa[j][2] + " " + saa[j][3] + " " + saa[j][4]),
                                            cName, tsGuid, sa, validPcdTypes)) {
                    return;
                }
            }
        }
        catch(Exception e) {
            JOptionPane.showMessageDialog(this, "Get PCD details fail: " + e.getMessage());
        }
    }

    /**
     * This method initializes jPanelPcdSouth
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelPcdSouth() {
        if (jPanelPcdSouth == null) {
            jLabelPcdHelp = new JLabel();
            jLabelPcdHelp.setText("PCD Description");
            jPanelPcdSouth = new JPanel();
            jPanelPcdSouth.setPreferredSize(new java.awt.Dimension(607,200));
            jPanelPcdSouth.add(jLabelPcdHelp, null);
            jPanelPcdSouth.add(getJScrollPanePcdHelp(), null);
            jPanelPcdSouth.add(getJPanelPcdFields(), null);
        }
        return jPanelPcdSouth;
    }

    /**
     * This method initializes jScrollPanePcdHelp
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPanePcdHelp() {
        if (jScrollPanePcdHelp == null) {
            jScrollPanePcdHelp = new JScrollPane();
            jScrollPanePcdHelp.setPreferredSize(new java.awt.Dimension(500,100));
            jScrollPanePcdHelp.setViewportView(getJTextAreaPcdHelp());
        }
        return jScrollPanePcdHelp;
    }

    /**
     * This method initializes jTextAreaPcdHelp
     * 	
     * @return javax.swing.JTextArea	
     */
    private JTextArea getJTextAreaPcdHelp() {
        if (jTextAreaPcdHelp == null) {
            jTextAreaPcdHelp = new JTextArea();
            jTextAreaPcdHelp.setEditable(false);
        }
        return jTextAreaPcdHelp;
    }

    /**
     * This method initializes jPanelContentPaneSouth
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelContentPaneSouth() {
        if (jPanelContentPaneSouth == null) {
            FlowLayout flowLayout = new FlowLayout();
            flowLayout.setAlignment(java.awt.FlowLayout.RIGHT);
            jPanelContentPaneSouth = new JPanel();
            jPanelContentPaneSouth.setLayout(flowLayout);
            jPanelContentPaneSouth.add(getJButtonOk(), null);
            jPanelContentPaneSouth.add(getJButtonCancel(), null);
        }
        return jPanelContentPaneSouth;
    }

    /**
     * This method initializes jSplitPane	
     * 	
     * @return javax.swing.JSplitPane	
     */
    private JSplitPane getJSplitPane() {
        if (jSplitPane == null) {
            jSplitPane = new JSplitPane();
            jSplitPane.setDividerLocation(200);
            jSplitPane.setLeftComponent(getJPanelLibraryLeft());
            jSplitPane.setRightComponent(getJPanelLibraryRight());
            jSplitPane.setPreferredSize(new java.awt.Dimension(202,200));
        }
        return jSplitPane;
    }

    /**
     * This method initializes jPanelLibraryLeft
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelLibraryLeft() {
        if (jPanelLibraryLeft == null) {
            jLabelLibClass = new JLabel();
            jLabelLibClass.setText("Library Classes Uninstantiated");
            jPanelLibraryLeft = new JPanel();
            jPanelLibraryLeft.add(jLabelLibClass, null);
            jPanelLibraryLeft.add(getJScrollPaneLibClass(), null);
        }
        return jPanelLibraryLeft;
    }

    /**
     * This method initializes jPanelLibraryRight
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelLibraryRight() {
        if (jPanelLibraryRight == null) {
            jLabelQualifiedInstance = new JLabel();
            jLabelQualifiedInstance.setText("Instances Available");
            jPanelLibraryRight = new JPanel();
            jPanelLibraryRight.add(jLabelQualifiedInstance, null);
            jPanelLibraryRight.add(getJScrollPaneQualifiedInstance(), null);
        }
        return jPanelLibraryRight;
    }

    /**
     * This method initializes jScrollPaneSelectedInstances
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneSelectedInstances() {
        if (jScrollPaneSelectedInstances == null) {
            jScrollPaneSelectedInstances = new JScrollPane();
            jScrollPaneSelectedInstances.setPreferredSize(new java.awt.Dimension(600,150));
            jScrollPaneSelectedInstances.setViewportView(getJTableSelectedInstances());
        }
        return jScrollPaneSelectedInstances;
    }

    /**
     * This method initializes jTableSelectedInstances
     * 	
     * @return javax.swing.JTable	
     */
    private JTable getJTableSelectedInstances() {
        if (jTableSelectedInstances == null) {
            selectedInstancesTableModel = new IDefaultTableModel();
            selectedInstancesTableModel.addColumn("Name");
            selectedInstancesTableModel.addColumn("ModuleGUID");
            selectedInstancesTableModel.addColumn("ModuleVersion");
            selectedInstancesTableModel.addColumn("PackageGUID");
            selectedInstancesTableModel.addColumn("PackageVersion");
            jTableSelectedInstances = new JTable(selectedInstancesTableModel);
            jTableSelectedInstances.setRowHeight(20);
            
            jTableSelectedInstances.getColumnModel().getColumn(0).setMinWidth(250);
            
            jTableSelectedInstances.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS);
            jTableSelectedInstances.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            
        }
        return jTableSelectedInstances;
    }

    /**
     * This method initializes jScrollPaneLibClass
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneLibClass() {
        if (jScrollPaneLibClass == null) {
            jScrollPaneLibClass = new JScrollPane();
            jScrollPaneLibClass.setPreferredSize(new java.awt.Dimension(200,170));
            jScrollPaneLibClass.setViewportView(getJTableLibClass());
        }
        return jScrollPaneLibClass;
    }

    /**
     * This method initializes jTableLibClass
     * 	
     * @return javax.swing.JTable	
     */
    private JTable getJTableLibClass() {
        if (jTableLibClass == null) {
            libClassTableModel = new IDefaultTableModel();
            libClassTableModel.addColumn("LibraryClass");
            libClassTableModel.addColumn("Arch");
            libClassTableModel.addColumn("ModType");
            jTableLibClass = new JTable(libClassTableModel);
            jTableLibClass.setRowHeight(20);
            jTableLibClass.setShowGrid(false);
            jTableLibClass.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            
            TableColumn column = jTableLibClass.getColumnModel().getColumn(1);
            jTableLibClass.getColumnModel().removeColumn(column);
            column = jTableLibClass.getColumnModel().getColumn(1);
            jTableLibClass.getColumnModel().removeColumn(column);
            
            jTableLibClass.getSelectionModel().addListSelectionListener(new ListSelectionListener(){
                public void valueChanged(ListSelectionEvent e) {
                    if (e.getValueIsAdjusting()){
                        return;
                    }
                    ListSelectionModel lsm = (ListSelectionModel)e.getSource();
                    if (lsm.isSelectionEmpty()) {
                        return;
                    }
                    else{
                        int selectedRow2 = lsm.getMinSelectionIndex();
                        if (selectedRow2 < 0) {
                            return;
                        }
                        //
                        // display potential lib instances according to class selection
                        //
                        libInstanceTableModel.setRowCount(0);
                        String cls = libClassTableModel.getValueAt(selectedRow2, 0).toString();
                        String arch = libClassTableModel.getValueAt(selectedRow2, 1).toString();
                        String modType = libClassTableModel.getValueAt(selectedRow2, 2).toString();
                        LibraryClassDescriptor lcd = new LibraryClassDescriptor(cls, arch, modType);
                        ArrayList<String> al = classInstanceMap.get(lcd);
                        if (al == null) {
                            al = getInstancesForClass(lcd, null);
                            if (al.size() != 0) {
                                classInstanceMap.put(lcd, al);
                            }
                            
                        }
                        ListIterator<String> li = al.listIterator();
                        while(li.hasNext()) {
                            String instance = li.next();
                            String[] s = {"", "", "", "", ""};
                            if (WorkspaceProfile.getModuleId(instance) != null) {
                                s[0] = WorkspaceProfile.getModuleId(instance).getName();
                            }
                            
                            String[] instancePart = instance.split(" ");
                            for (int i = 0; i < instancePart.length; ++i){
                                s[i+1] = instancePart[i];
                            }
                            libInstanceTableModel.addRow(s);
                        }
                        
                    }
                }
            });
        }
        return jTableLibClass;
    }

    /**
     * This method initializes jScrollPaneQualifiedInstance
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneQualifiedInstance() {
        if (jScrollPaneQualifiedInstance == null) {
            jScrollPaneQualifiedInstance = new JScrollPane();
            jScrollPaneQualifiedInstance.setPreferredSize(new java.awt.Dimension(600,170));
            jScrollPaneQualifiedInstance.setViewportView(getJTableLibInstances());
        }
        return jScrollPaneQualifiedInstance;
    }

    /**
     * This method initializes jTableLibInstances
     * 	
     * @return javax.swing.JTable	
     */
    private JTable getJTableLibInstances() {
        if (jTableLibInstances == null) {
            libInstanceTableModel = new IDefaultTableModel();
            libInstanceTableModel.addColumn("Name");
            libInstanceTableModel.addColumn("ModuleGUID");
            libInstanceTableModel.addColumn("ModuleVersion");
            libInstanceTableModel.addColumn("PackageGUID");
            libInstanceTableModel.addColumn("PackageVersion");
            jTableLibInstances = new JTable(libInstanceTableModel);
            jTableLibInstances.setRowHeight(20);
            
            jTableLibInstances.getColumnModel().getColumn(0).setMinWidth(250);
            
            jTableLibInstances.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS);
            jTableLibInstances.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            
        }
        return jTableLibInstances;
    }

    /**
     * This method initializes jPanelLibrarySouth
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelLibrarySouth() {
        if (jPanelLibrarySouth == null) {
            jPanelLibrarySouth = new JPanel();
        }
        return jPanelLibrarySouth;
    }

    /**
     * This method initializes jPanelLibraryCenter
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelLibraryCenter() {
        if (jPanelLibraryCenter == null) {
            jLabelInstanceHelp = new JLabel();
            jLabelInstanceHelp.setText("Instance Description");
            jLabelSelectedInstances = new JLabel();
            jLabelSelectedInstances.setText("Selected Instances");
            jPanelLibraryCenter = new JPanel();
            jPanelLibraryCenter.setLayout(new BorderLayout());

            jPanelLibraryCenter.add(getJPanelLibraryCenterC(), java.awt.BorderLayout.CENTER);
            jPanelLibraryCenter.add(getJPanelLibraryCenterN(), java.awt.BorderLayout.NORTH);

        }
        return jPanelLibraryCenter;
    }

    /**
     * This method initializes jScrollPaneInstanceHelp
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneInstanceHelp() {
        if (jScrollPaneInstanceHelp == null) {
            jScrollPaneInstanceHelp = new JScrollPane();
            jScrollPaneInstanceHelp.setPreferredSize(new java.awt.Dimension(400,50));
            jScrollPaneInstanceHelp.setViewportView(getJTextAreaInstanceHelp());
        }
        return jScrollPaneInstanceHelp;
    }

    /**
     * This method initializes jTextAreaInstanceHelp
     * 	
     * @return javax.swing.JTextArea	
     */
    private JTextArea getJTextAreaInstanceHelp() {
        if (jTextAreaInstanceHelp == null) {
            jTextAreaInstanceHelp = new JTextArea();
            jTextAreaInstanceHelp.setEditable(false);
        }
        return jTextAreaInstanceHelp;
    }

    /**
     * This method initializes jButtonAdd
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonAdd() {
        if (jButtonAdd == null) {
            jButtonAdd = new JButton();
            jButtonAdd.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonAdd.setText("Add");
            jButtonAdd.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    int row = jTableLibInstances.getSelectedRow();
                    if (row < 0) {
                        return;
                    }
                    
                    String libInstanceKey = libInstanceTableModel.getValueAt(row, 1) + " " +
                    libInstanceTableModel.getValueAt(row, 2) + " " +
                    libInstanceTableModel.getValueAt(row, 3) + " " +
                    libInstanceTableModel.getValueAt(row, 4);
                    ModuleIdentification libMi = WorkspaceProfile.getModuleId(libInstanceKey);
                    try {
                        addLibInstance (libMi);
                    }
                    catch (Exception exception) {
                        JOptionPane.showMessageDialog(FpdModuleSA.this, "Adding Instance " + libMi.getName() + " : \n"+ exception.getMessage());
                        return;
                    }
                    docConsole.setSaved(false);
                    Object[] s = {libInstanceTableModel.getValueAt(row, 0), libInstanceTableModel.getValueAt(row, 1),
                                  libInstanceTableModel.getValueAt(row, 2), libInstanceTableModel.getValueAt(row, 3),
                                  libInstanceTableModel.getValueAt(row, 4)};
                    selectedInstancesTableModel.addRow(s);
                    
                    Vector<LibraryClassDescriptor> vLcd = addConsumedClassFromModule (libInstanceKey);
                    addProducedClassFromModule (libInstanceKey);
                    
                    Vector<String> errorMsg = new Vector<String>();
                    Vector<ModuleIdentification> newInstances = new Vector<ModuleIdentification>();
                    Stack<LibraryClassDescriptor> lcdStack = new Stack<LibraryClassDescriptor>();
                    for (int i = 0; i < vLcd.size(); ++i) {
                        LibraryClassDescriptor lcd = vLcd.get(i);
                        if (!lcdStack.contains(lcd)) {
                            lcdStack.push(lcd);
                        }
                    }
                    try {
                        resolveLibraryInstances(lcdStack, true, errorMsg, newInstances);
                    }
                    catch (Exception exp) {
                        JOptionPane.showMessageDialog(FpdModuleSA.this, exp.getMessage());
                    }
                    
                    showClassToResolved();
                    
                    if (errorMsg.size() > 0) {
                        String errors = "";
                        for (int i = 0; i < errorMsg.size(); ++i) {
                            errors += " " + errorMsg.get(i) + "\n";
                        }
                        JOptionPane.showMessageDialog(FpdModuleSA.this, errors);
                    }
                }
            });
        }
        return jButtonAdd;
    }

    /**
     * This method initializes jButton1
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonDeleteInstance() {
        if (jButtonDeleteInstance == null) {
            jButtonDeleteInstance = new JButton();
            jButtonDeleteInstance.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonDeleteInstance.setText("Delete");
            jButtonDeleteInstance.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    int row = jTableSelectedInstances.getSelectedRow();
                    if (row < 0) {
                        return;
                    }
                    docConsole.setSaved(false);
                    String instanceKey = selectedInstancesTableModel.getValueAt(row, 1) + " "
                                         + selectedInstancesTableModel.getValueAt(row, 2) + " "
                                         + selectedInstancesTableModel.getValueAt(row, 3) + " "
                                         + selectedInstancesTableModel.getValueAt(row, 4);
                    removeInstance(instanceKey);
                    
                    selectedInstancesTableModel.setRowCount(0);
                    int instanceCount = ffc.getLibraryInstancesCount(moduleKey);
                    if (instanceCount != 0) {
                        String[][] saa = new String[instanceCount][5];
                        ffc.getLibraryInstances(moduleKey, saa);
                        for (int i = 0; i < saa.length; ++i) {
                            String libInstanceKey = saa[i][1] + " " + saa[i][2] + " " + saa[i][3] + " " + saa[i][4];
                            ModuleIdentification mi = WorkspaceProfile.getModuleId(libInstanceKey);
                            if (mi != null) {
                                //
                                // ToDo: verify this instance first.
                                //
                                saa[i][0] = mi.getName();
                                saa[i][2] = mi.getVersion();
                                saa[i][4] = mi.getPackageId().getVersion();
                                selectedInstancesTableModel.addRow(saa[i]);
                            }
                        }
                    }
                    showClassToResolved();
                }
            });
        }
        return jButtonDeleteInstance;
    }

    /**
     * This method initializes jButton2	
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonOk() {
        if (jButtonOk == null) {
            jButtonOk = new JButton();
            jButtonOk.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonOk.setText("Close");
            jButtonOk.addActionListener(this);
        }
        return jButtonOk;
    }

    /**
     * This method initializes jButton3	
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonCancel() {
        if (jButtonCancel == null) {
            jButtonCancel = new JButton();
            jButtonCancel.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonCancel.setText("Cancel");
            jButtonCancel.setVisible(false);
        }
        return jButtonCancel;
    }
    public void actionPerformed(ActionEvent arg0) {

        if (arg0.getSource() == jButtonOk) {
            if (jTableModuleSaOptions.isEditing()) {
                jTableModuleSaOptions.getCellEditor().stopCellEditing();
            }
            this.setVisible(false);
        }
    }
    /**
     * This method initializes jPanelModuleSaOpts
     * 	
     * @return javax.swing.JPanel	
     */
    private JPanel getJPanelModuleSaOpts() {
        if (jPanelModuleSaOpts == null) {
            FlowLayout flowLayout4 = new FlowLayout();
            flowLayout4.setAlignment(java.awt.FlowLayout.LEFT);
            jLabelFfsFormatKey = new JLabel();
            jLabelFfsFormatKey.setText("FFS Format Key");
            jLabelFfsFormatKey.setPreferredSize(new java.awt.Dimension(90,16));
            jLabelFfsFileGuid = new JLabel();
            jLabelFfsFileGuid.setText("FFS File GUID");
            jLabelFfsFileGuid.setPreferredSize(new java.awt.Dimension(90,16));
            jLabelFfsFileGuid.setVisible(false);
            jLabelFvBinding = new JLabel();
            jLabelFvBinding.setText("FV Binding");
            jLabelFvBinding.setPreferredSize(new java.awt.Dimension(90,16));
            jPanelModuleSaOpts = new JPanel();
            jPanelModuleSaOpts.setLayout(flowLayout4);
            jPanelModuleSaOpts.add(jLabelFvBinding, null);
            jPanelModuleSaOpts.add(getJTextFieldFvBinding(), null);
            jPanelModuleSaOpts.add(jLabelFfsFileGuid, null);
            jPanelModuleSaOpts.add(getJTextFieldFileGuid(), null);
            jPanelModuleSaOpts.add(jLabelFfsFormatKey, null);
            jPanelModuleSaOpts.add(getJTextFieldFfsKey(), null);
            jPanelModuleSaOpts.addComponentListener(new java.awt.event.ComponentAdapter() {
                public void componentShown(java.awt.event.ComponentEvent e) {
                    initFvInfo(moduleKey);
                }
            });
        }
        return jPanelModuleSaOpts;
    }
    
    private Vector<String> getVectorFromString (String s) {
        if (s == null || s.equals("null")) {
            s = "";
        }
        String[] sa1 = s.split(" ");
        Vector<String> v = new Vector<String>();
        for (int i = 0; i < sa1.length; ++i) {
            v.add(sa1[i]);
        }
        return v;
    }
    
    /**
     * This method initializes jTextField	
     * 	
     * @return javax.swing.JTextField	
     */
    private JTextField getJTextFieldFvBinding() {
        if (jTextFieldFvBinding == null) {
            jTextFieldFvBinding = new JTextField();
            jTextFieldFvBinding.setPreferredSize(new java.awt.Dimension(400,20));
            jTextFieldFvBinding.setEditable(true);
            jTextFieldFvBinding.addFocusListener(new java.awt.event.FocusAdapter() {
                public void focusLost(java.awt.event.FocusEvent e) {
                    String originalFvBinding = ffc.getFvBinding(moduleKey);
                    String newFvBinding = jTextFieldFvBinding.getText();
                    if (newFvBinding.equals(originalFvBinding)) {
                        return;
                    }
                    if (newFvBinding.length() == 0 && originalFvBinding == null) {
                        return;
                    }
                    
                    Vector<String> oldFvList = getVectorFromString (originalFvBinding);
                    Vector<String> newFvList = getVectorFromString (newFvBinding);
                    String moduleInfo[] = moduleKey.split(" ");
                    ffc.setFvBinding(moduleKey, newFvBinding);
                    //
                    // remove module from Fvs that not in newFvList now.
                    //
                    oldFvList.removeAll(newFvList);
                    for (int j = 0; j < oldFvList.size(); ++j) {
                        ffc.removeModuleInBuildOptionsUserExtensions(oldFvList.get(j), "IMAGES", "1", moduleInfo[0], moduleInfo[1], moduleInfo[2], moduleInfo[3], moduleInfo[4]);    
                    }
                    //
                    // add module to Fvs that were not in oldFvList.
                    //
                    oldFvList = getVectorFromString (originalFvBinding);
                    newFvList.removeAll(oldFvList);
                    for (int i = 0; i < newFvList.size(); ++i) {
                        ffc.addModuleIntoBuildOptionsUserExtensions(newFvList.get(i), "IMAGES", "1", moduleInfo[0], moduleInfo[1], moduleInfo[2], moduleInfo[3], moduleInfo[4]);
                    }
                    docConsole.setSaved(false);
                }
            });
            
        }
        return jTextFieldFvBinding;
    }
    /**
     * This method initializes jTextField1	
     * 	
     * @return javax.swing.JTextField	
     */
    private JTextField getJTextFieldFileGuid() {
        if (jTextFieldFileGuid == null) {
            jTextFieldFileGuid = new JTextField();
            jTextFieldFileGuid.setPreferredSize(new java.awt.Dimension(300,20));
            jTextFieldFileGuid.setVisible(false);
            jTextFieldFileGuid.addFocusListener(new java.awt.event.FocusAdapter() {
                public void focusLost(java.awt.event.FocusEvent e) {
                    String originalFileGuid = ffc.getFfsFileNameGuid(moduleKey);
                    String newFileGuid = jTextFieldFileGuid.getText();
                    if (newFileGuid.equals(originalFileGuid)) {
                        return;
                    }
                    if (newFileGuid.length() == 0 && originalFileGuid == null) {
                        return;
                    }
                    if (newFileGuid.length() > 0) {
                        if (!DataValidation.isGuid(newFileGuid)) {
                            JOptionPane.showMessageDialog(FpdModuleSA.this, "FFS File Guid is NOT GUID Type.");
                            return;
                        }
                    }
                    
                    docConsole.setSaved(false);
                    if (newFileGuid.length() == 0) {
                        newFileGuid = null;
                    }
                    ffc.setFfsFileNameGuid(moduleKey, newFileGuid);
                }
            });
            
        }
        return jTextFieldFileGuid;
    }
    /**
     * This method initializes jTextFieldFfsKey	
     * 	
     * @return javax.swing.JTextField	
     */
    private JTextField getJTextFieldFfsKey() {
        if (jTextFieldFfsKey == null) {
            jTextFieldFfsKey = new JTextField();
            jTextFieldFfsKey.setPreferredSize(new java.awt.Dimension(250,20));
            jTextFieldFfsKey.addFocusListener(new java.awt.event.FocusAdapter() {
                public void focusLost(java.awt.event.FocusEvent e) {
                    String originalFfsKey = ffc.getFfsFormatKey(moduleKey);
                    String newFfsKey = jTextFieldFfsKey.getText();
                    if (newFfsKey.equals(originalFfsKey)) {
                        return;
                    }
                    if (newFfsKey.length() == 0 && originalFfsKey == null) {
                        return;
                    }
                    docConsole.setSaved(false);
                    ffc.setFfsFormatKey(moduleKey, newFfsKey);
                }
            });
            
        }
        return jTextFieldFfsKey;
    }
    /**
     * This method initializes jScrollPaneModuleSaOptions
     * 	
     * @return javax.swing.JScrollPane	
     */
    private JScrollPane getJScrollPaneModuleSaOptions() {
        if (jScrollPaneModuleSaOptions == null) {
            jScrollPaneModuleSaOptions = new JScrollPane();
            jScrollPaneModuleSaOptions.setPreferredSize(new java.awt.Dimension(600,350));
            jScrollPaneModuleSaOptions.setViewportView(getJTableModuleSaOptions());
        }
        return jScrollPaneModuleSaOptions;
    }
    /**
     * This method initializes jTableModuleSaOptions
     * 	
     * @return javax.swing.JTable	
     */
    private JTable getJTableModuleSaOptions() {
        if (jTableModuleSaOptions == null) {
            optionsTableModel = new DefaultTableModel();
            optionsTableModel.addColumn("BuildTargets");
            optionsTableModel.addColumn("ToolChainFamily");
            optionsTableModel.addColumn("TagName");
            optionsTableModel.addColumn("ToolCode");
            optionsTableModel.addColumn("SupportedArchs");
            optionsTableModel.addColumn("Contents");
            jTableModuleSaOptions = new JTable(optionsTableModel);
            jTableModuleSaOptions.setRowHeight(20);
            
            jTableModuleSaOptions.getColumnModel().getColumn(0).setMinWidth(buildTargetWidth);
            jTableModuleSaOptions.getColumnModel().getColumn(1).setMinWidth(toolChainFamilyWidth);
            jTableModuleSaOptions.getColumnModel().getColumn(2).setMinWidth(tagNameWidth);
            jTableModuleSaOptions.getColumnModel().getColumn(3).setMinWidth(toolCmdCodeWidth);
            jTableModuleSaOptions.getColumnModel().getColumn(4).setMinWidth(supportArchWidth);
            jTableModuleSaOptions.getColumnModel().getColumn(5).setMinWidth(argWidth);
//            javax.swing.table.TableColumn toolFamilyCol = jTableModuleSaOptions.getColumnModel().getColumn(1);
//            JComboBox cb = new JComboBox();
//            cb.addItem("MSFT");
//            cb.addItem("GCC");
//            cb.addItem("CYGWIN");
//            cb.addItem("INTEL");
//            cb.addItem("USER_DEFINED");
//            toolFamilyCol.setCellEditor(new DefaultCellEditor(cb));
            
            Vector<String> vArch = new Vector<String>();
            vArch.add("IA32");
            vArch.add("X64");
            vArch.add("IPF");
            vArch.add("EBC");
            vArch.add("ARM");
            vArch.add("PPC");
            jTableModuleSaOptions.getColumnModel().getColumn(4).setCellEditor(new ListEditor(vArch, FrameworkWizardUI.getInstance()));
            
            jTableModuleSaOptions.getColumnModel().getColumn(5).setCellEditor(new LongTextEditor(FrameworkWizardUI.getInstance()));
            
            jTableModuleSaOptions.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
			jTableModuleSaOptions.setAutoResizeMode(javax.swing.JTable.AUTO_RESIZE_OFF);
            jTableModuleSaOptions.getModel().addTableModelListener(new TableModelListener() {
                public void tableChanged(TableModelEvent arg0) {
                    // TODO Auto-generated method stub
                    int row = arg0.getFirstRow();
                    TableModel m = (TableModel)arg0.getSource();
                    
                    if (arg0.getType() == TableModelEvent.UPDATE){
                        //ToDo Data Validition check.
                        String targets = m.getValueAt(row, 0) + "";
                        Vector<Object> targetName = null;
                        if (targets.length() > 0) {
                            targetName = new Vector<Object>();
                            String[] sArray = targets.split(" ");
                            for (int i = 0; i < sArray.length; ++i) {
                                targetName.add(sArray[i]);
                            }
                        }
                        
                        String toolChain = m.getValueAt(row, 1) + "";
                        String tagName = m.getValueAt(row, 2) + "";
                        String toolCode = m.getValueAt(row, 3) + "";
                        String archs = m.getValueAt(row, 4) + "";
                        Vector<Object> supArch = null;
                        if (archs.length() > 0) {
                            supArch = new Vector<Object>();
                            String[] sArray1 = archs.split(" ");
                            for (int i = 0; i < sArray1.length; ++i) {
                                supArch.add(sArray1[i]);
                            }
                        }
                        
                        String contents = m.getValueAt(row, 5) + "";
                        docConsole.setSaved(false);
                        ffc.updateModuleSAOptionsOpt(moduleKey, row, targetName, toolChain, tagName, toolCode, supArch, contents);
                    }
                }
            });
        }
        return jTableModuleSaOptions;
    }
    /**
     * This method initializes jButtonNew
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonNew() {
        if (jButtonNew == null) {
            jButtonNew = new JButton();
            jButtonNew.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonNew.setText("New");
            jButtonNew.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    String[] row = {"", "", "", "", "", ""};
                    optionsTableModel.addRow(row);
                    Vector<Object> v = null;
                    Vector<Object> v1 = null;
                    docConsole.setSaved(false);
                    ffc.genModuleSAOptionsOpt(moduleKey, v, "", "", "", v1, "");
                }
            });
        }
        return jButtonNew;
    }
    /**
     * This method initializes jButtonDelete
     * 	
     * @return javax.swing.JButton	
     */
    private JButton getJButtonDeleteOption() {
        if (jButtonDeleteOption == null) {
            jButtonDeleteOption = new JButton();
            jButtonDeleteOption.setPreferredSize(new java.awt.Dimension(80,20));
            jButtonDeleteOption.setText("Delete");
            jButtonDeleteOption.addActionListener(new java.awt.event.ActionListener() {
                public void actionPerformed(java.awt.event.ActionEvent e) {
                    if (jTableModuleSaOptions.getSelectedRow() < 0) {
                        return;
                    }
                    docConsole.setSaved(false);
                    ffc.removeModuleSAOptionsOpt(moduleKey, jTableModuleSaOptions.getSelectedRow());
                    optionsTableModel.removeRow(jTableModuleSaOptions.getSelectedRow());
                }
            });
        }
        return jButtonDeleteOption;
    }
    
    /**
    Start the window at the center of screen
    
    **/
   protected void centerWindow(int intWidth, int intHeight) {
       Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
       this.setLocation((d.width - intWidth) / 2, (d.height - intHeight) / 2);
   }

   /**
    Start the window at the center of screen
    
    **/
   protected void centerWindow() {
       centerWindow(this.getSize().width, this.getSize().height);
   }
/**
 * This method initializes jPanelPcdFields
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelPcdFields() {
    if (jPanelPcdFields == null) {
        GridLayout gridLayout = new GridLayout();
        gridLayout.setRows(3);
        gridLayout.setColumns(2);
        jPanelPcdFields = new JPanel();
        jPanelPcdFields.setLayout(gridLayout);
        jPanelPcdFields.setPreferredSize(new java.awt.Dimension(600,90));
        jPanelPcdFields.add(getJPanelPcdFieldsFirstRow(), null);
        jPanelPcdFields.add(getJPanelPcdFieldsSecondRow(), null);
        jPanelPcdFields.add(getJPanelPcdFieldsThirdRow(), null);
    }
    return jPanelPcdFields;
}
/**
 * This method initializes jPanelPcdFieldsSecondRow
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelPcdFieldsSecondRow() {
    if (jPanelPcdFieldsSecondRow == null) {
        FlowLayout flowLayout2 = new FlowLayout();
        flowLayout2.setAlignment(java.awt.FlowLayout.LEFT);
        jLabelMaxDatumSize = new JLabel();
        jLabelMaxDatumSize.setText("Max Datum Size");
        jPanelPcdFieldsSecondRow = new JPanel();
        jPanelPcdFieldsSecondRow.setLayout(flowLayout2);
        jPanelPcdFieldsSecondRow.add(jLabelMaxDatumSize, null);
        jPanelPcdFieldsSecondRow.add(getJTextFieldMaxDatumSize(), null);
    }
    return jPanelPcdFieldsSecondRow;
}
/**
 * This method initializes jPanelPcdFieldsThirdRow
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelPcdFieldsThirdRow() {
    if (jPanelPcdFieldsThirdRow == null) {
        FlowLayout flowLayout3 = new FlowLayout();
        flowLayout3.setAlignment(java.awt.FlowLayout.LEFT);
        jLabelPcdDefaultValue = new JLabel();
        jLabelPcdDefaultValue.setText("Default Value");
        jLabelPcdDefaultValue.setPreferredSize(new java.awt.Dimension(91,16));
        jPanelPcdFieldsThirdRow = new JPanel();
        jPanelPcdFieldsThirdRow.setLayout(flowLayout3);
        jPanelPcdFieldsThirdRow.add(jLabelPcdDefaultValue, null);
        jPanelPcdFieldsThirdRow.add(getJTextFieldPcdDefault(), null);
        jPanelPcdFieldsThirdRow.add(getJComboBoxFeatureFlagValue(), null);
        jPanelPcdFieldsThirdRow.add(getJButtonUpdatePcd(), null);
    }
    return jPanelPcdFieldsThirdRow;
}
/**
 * This method initializes jPanelPcdFieldsFirstRow
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelPcdFieldsFirstRow() {
    if (jPanelPcdFieldsFirstRow == null) {
        FlowLayout flowLayout1 = new FlowLayout();
        flowLayout1.setAlignment(java.awt.FlowLayout.LEFT);
        jLabelItemType = new JLabel();
        jLabelItemType.setText("Item Type");
        jLabelItemType.setPreferredSize(new java.awt.Dimension(91,16));
        jPanelPcdFieldsFirstRow = new JPanel();
        jPanelPcdFieldsFirstRow.setLayout(flowLayout1);
        jPanelPcdFieldsFirstRow.add(jLabelItemType, null);
        jPanelPcdFieldsFirstRow.add(getJComboBoxItemType(), null);
    }
    return jPanelPcdFieldsFirstRow;
}
/**
 * This method initializes jComboBoxItemType
 * 	
 * @return javax.swing.JComboBox	
 */
private JComboBox getJComboBoxItemType() {
    if (jComboBoxItemType == null) {
        jComboBoxItemType = new JComboBox();
        jComboBoxItemType.setPreferredSize(new java.awt.Dimension(200,20));
        jComboBoxItemType.addItemListener(new java.awt.event.ItemListener() {
            public void itemStateChanged(java.awt.event.ItemEvent e) {
                
                int row = jTablePcd.getSelectedRow();
                if (row < 0) {
                    return;
                }
                        
                if (jComboBoxItemType.getSelectedItem() != null && jComboBoxItemType.getSelectedItem().equals("FIXED_AT_BUILD")) {
				    jTextFieldPcdDefault.setEnabled(true);
                }
                else {
                	jTextFieldPcdDefault.setEnabled(false);
                }
            }        
        });
    }
    return jComboBoxItemType;
}

private void pcdDynamicToNonDynamic(String cName, String tsGuid) {
    String[][] saa = new String[ffc.getDynamicPcdBuildDataCount()][5];
    ffc.getDynamicPcdBuildData(saa);
    String maxSize = "";
    String value = "";
    for (int i = 0; i < saa.length; ++i) {
        if (saa[i][0].equals(cName) && saa[i][2].equals(tsGuid)) {
            maxSize = saa[i][3];
            value = ffc.getDynamicPcdBuildDataValue(i);
            break;
        }
    }
    
    ArrayList<String> al = ffc.getDynPcdMapValue(cName + " " + tsGuid);
    for (int i = 0; i < al.size(); ++i) {
        String mKey = moduleInfo (al.get(i));
        value = null;
        String itemType = jComboBoxItemType.getSelectedItem()+"";
        ffc.updatePcdData(mKey, cName, tsGuid, itemType, maxSize, value);
        al.set(i, mKey + " " + itemType);
    }
    
    ffc.removeDynamicPcdBuildData(cName, tsGuid);
}

private void pcdNonDynamicToDynamic(String cName, String tsGuid) {
    ArrayList<String> al = ffc.getDynPcdMapValue(cName + " " + tsGuid);
    for (int i = 0; i < al.size(); ++i) {
        String mKey = moduleInfo (al.get(i));
        String itemType = jComboBoxItemType.getSelectedItem()+"";
        ffc.updatePcdData(mKey, cName, tsGuid, itemType, jTextFieldMaxDatumSize.getText(), jTextFieldPcdDefault.isVisible() ? jTextFieldPcdDefault.getText() : jComboBoxFeatureFlagValue.getSelectedItem()+"");
        al.set(i, mKey + " " + itemType);
    }
    try{
        ffc.addDynamicPcdBuildData(cName, model.getValueAt(jTablePcd.getSelectedRow(), 3), tsGuid, "DYNAMIC", model.getValueAt(jTablePcd.getSelectedRow(), 5)+"", jTextFieldPcdDefault.isVisible() ? jTextFieldPcdDefault.getText() : jComboBoxFeatureFlagValue.getSelectedItem()+"");
    }
    catch(Exception e){
        JOptionPane.showMessageDialog(FpdModuleSA.this, "PCD value format: " + e.getMessage());
    }
}

private void changePcdTypeWithinSameCategory (String cName, String tsGuid) {
    ArrayList<String> al = ffc.getDynPcdMapValue(cName + " " + tsGuid);
    for (int i = 0; i < al.size(); ++i) {
        String mKey = moduleInfo (al.get(i));
        String itemType = jComboBoxItemType.getSelectedItem()+"";
        ffc.updatePcdData(mKey, cName, tsGuid, itemType, null, null);
        al.set(i, mKey + " " + itemType);
    }
}

private String moduleInfo (String pcdInfo) {
    
    return pcdInfo.substring(0, pcdInfo.lastIndexOf(" "));
}

/**
 * This method initializes jTextFieldMaxDatumSize
 * 	
 * @return javax.swing.JTextField	
 */
private JTextField getJTextFieldMaxDatumSize() {
    if (jTextFieldMaxDatumSize == null) {
        jTextFieldMaxDatumSize = new JTextField();
        jTextFieldMaxDatumSize.setPreferredSize(new java.awt.Dimension(200,20));
    }
    return jTextFieldMaxDatumSize;
}
/**
 * This method initializes jTextField4	
 * 	
 * @return javax.swing.JTextField	
 */
private JTextField getJTextFieldPcdDefault() {
    if (jTextFieldPcdDefault == null) {
        jTextFieldPcdDefault = new JTextField();
        jTextFieldPcdDefault.setPreferredSize(new java.awt.Dimension(200,20));
    }
    return jTextFieldPcdDefault;
}
/**
 * This method initializes jButton6	
 * 	
 * @return javax.swing.JButton	
 */
private JButton getJButtonUpdatePcd() {
    if (jButtonUpdatePcd == null) {
        jButtonUpdatePcd = new JButton();
        jButtonUpdatePcd.setPreferredSize(new java.awt.Dimension(150,20));
        jButtonUpdatePcd.setText("Update PCD Data");
        jButtonUpdatePcd.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent e) {
                int row = jTablePcd.getSelectedRow();
                if (row < 0) {
                    return;
                }
                
                String cName = model.getValueAt(row, 0)+"";
                String tsGuid = model.getValueAt(row, 1)+"";
                String oldItemType = model.getValueAt(row, 2)+"";
                String dataType = model.getValueAt(row, 5)+"";
                String newItemType = jComboBoxItemType.getSelectedItem()+"";
                String newValue = jTextFieldPcdDefault.isVisible()? jTextFieldPcdDefault.getText():jComboBoxFeatureFlagValue.getSelectedItem()+""; 
                if (newValue.length() == 0){
                
                    if (dataType.equals("UINT8") || dataType.equals("UINT16") || dataType.equals("UINT32") || dataType.equals("UINT64")) {
                        newValue = "0";
                    }
                    if (dataType.equals("BOOLEAN")){
                        newValue = "FALSE";
                    }
                    if (dataType.equals("VOID*")) {
                        newValue = "L\"\"";
                    }
                }
                
                String[] pcdInfo = {"", "", ""};
                Vector<String> validPcdTypes = new Vector<String>();
                getPcdInfo (moduleKey, cName, tsGuid, pcdInfo, validPcdTypes);
                if (pcdInfo[1].equals("FIXED_AT_BUILD") && model.getValueAt(row, 5).equals("VOID*")) {
                    try {
                        jTextFieldMaxDatumSize.setText(ffc.setMaxSizeForPointer(newValue)+"");
                    }
                    catch (Exception exp) {
                        JOptionPane.showMessageDialog(FpdModuleSA.this, "PCD Value MalFormed: " + exp.getMessage());
                        return;
                    }
                }
                String newMaxDatumSize = jTextFieldMaxDatumSize.getText();
                
                if (!newItemType.equals(oldItemType)) {
                    Vector<ModuleIdentification> moduleInfo = new Vector<ModuleIdentification>();
                    try {
                        boolean changable = itemTypeCouldBeChanged (cName, tsGuid, newItemType, moduleInfo);
                        if (!changable) {
                            JOptionPane.showMessageDialog(FpdModuleSA.this, "Can NOT Change Pcd Type in: " + moduleInfo.get(0).getName() + " contained in package " + moduleInfo.get(0).getPackageId().getName());
                            return;
                        }
                    }
                    catch (Exception exp) {
                        JOptionPane.showMessageDialog(FpdModuleSA.this, "Can NOT Change Pcd Type in: " + moduleInfo.get(0).getName() + " contained in package " + moduleInfo.get(0).getPackageId().getName() + " " + exp.getMessage());
                        return;
                    }
                    
                    if ((oldItemType.equals("DYNAMIC") || oldItemType.equals("DYNAMIC_EX")) && !newItemType.equals("DYNAMIC") && !newItemType.equals("DYNAMIC_EX")) {
                        pcdDynamicToNonDynamic(cName, tsGuid);
                    }
                    if (!oldItemType.equals("DYNAMIC") && !oldItemType.equals("DYNAMIC_EX") && (newItemType.equals("DYNAMIC") || newItemType.equals("DYNAMIC_EX"))) {
                        pcdNonDynamicToDynamic(cName, tsGuid);
                    }
                    else {
                        changePcdTypeWithinSameCategory (cName, tsGuid);
                    }
                    model.setValueAt(newItemType, row, 2);
                }
                
                ffc.updatePcdData(moduleKey, cName, tsGuid, model.getValueAt(row, 2)+"", newMaxDatumSize, newValue);
                docConsole.setSaved(false);
                model.setValueAt(newValue, row, 6);
                model.setValueAt(newMaxDatumSize, row, 4);
                
            }
        });
    }
    return jButtonUpdatePcd;
}

private boolean itemTypeCouldBeChanged (String cName, String tsGuid, String newItemType, Vector<ModuleIdentification> mi) throws Exception{
    ArrayList<String> pcdConsumers = ffc.getDynPcdMapValue(cName + " " + tsGuid);
    for (int i = 0; i < pcdConsumers.size(); ++i) {
        String consumerInfo = moduleInfo (pcdConsumers.get(i));
        mi.removeAllElements();
        mi.add(WorkspaceProfile.getModuleId(consumerInfo));
        String[] sa = {"", "", ""};
        Vector<String> validPcdTypes = new Vector<String>();
        getPcdInfo (consumerInfo, cName, tsGuid, sa, validPcdTypes);
        if (validPcdTypes.size() == 0) {
            return false;
        }
        if (!sa[1].equals("DYNAMIC")) {
            return false;
        }
        if (!validPcdTypes.contains(newItemType)) {
            return false;
        }
    }
    return true;
}

/**
 * This method initializes jComboBoxFeatureFlagValue
 * 	
 * @return javax.swing.JComboBox	
 */
private JComboBox getJComboBoxFeatureFlagValue() {
    if (jComboBoxFeatureFlagValue == null) {
        jComboBoxFeatureFlagValue = new JComboBox();
        jComboBoxFeatureFlagValue.setPreferredSize(new java.awt.Dimension(100,20));
        jComboBoxFeatureFlagValue.setVisible(false);
        jComboBoxFeatureFlagValue.addItem("TRUE");
        jComboBoxFeatureFlagValue.addItem("FALSE");
    }
    return jComboBoxFeatureFlagValue;
}
/**
 * This method initializes jPanelCustomToolChain	
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelCustomToolChain() {
    if (jPanelCustomToolChain == null) {
        jPanelCustomToolChain = new JPanel();
        jPanelCustomToolChain.setLayout(new BorderLayout());
        jPanelCustomToolChain.add(getJPanelToolchainS(), java.awt.BorderLayout.SOUTH);
        jPanelCustomToolChain.add(getJScrollPaneModuleSaOptions(), java.awt.BorderLayout.CENTER);
        jPanelCustomToolChain.addComponentListener(new java.awt.event.ComponentAdapter() {
            public void componentShown(java.awt.event.ComponentEvent e) {
                initToolChainOptions(moduleKey);
            }
        });
    }
    return jPanelCustomToolChain;
}
/**
 * This method initializes jPanelToolchainS	
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelToolchainS() {
    if (jPanelToolchainS == null) {
        jPanelToolchainS = new JPanel();
        jPanelToolchainS.add(getJButtonNew(), null);
        jPanelToolchainS.add(getJButtonDeleteOption(), null);
    }
    return jPanelToolchainS;
}

/**
 * This method initializes jPanelLibraryCenterN	
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelLibraryCenterN() {
    if (jPanelLibraryCenterN == null) {
        FlowLayout flowLayout5 = new FlowLayout();
        flowLayout5.setAlignment(java.awt.FlowLayout.CENTER);
        flowLayout5.setHgap(10);
        jPanelLibraryCenterN = new JPanel();
        jPanelLibraryCenterN.setLayout(flowLayout5);
        jPanelLibraryCenterN.add(jLabelInstanceHelp, null);
        jPanelLibraryCenterN.add(getJScrollPaneInstanceHelp(), null);
        jPanelLibraryCenterN.add(getJButtonAdd(), null);
        jPanelLibraryCenterN.add(getJButtonDeleteInstance(), null);
    }
    return jPanelLibraryCenterN;
}
/**
 * This method initializes jPanelLibraryCenterC	
 * 	
 * @return javax.swing.JPanel	
 */
private JPanel getJPanelLibraryCenterC() {
    if (jPanelLibraryCenterC == null) {
        jPanelLibraryCenterC = new JPanel();
        jPanelLibraryCenterC.add(jLabelSelectedInstances, null);
        jPanelLibraryCenterC.add(getJScrollPaneSelectedInstances(), null);
    }
    return jPanelLibraryCenterC;
}


}  //  @jve:decl-index=0:visual-constraint="10,10"

class MultipleInstanceException extends Exception {

    /**
     * 
     */
    private static final long serialVersionUID = -9148463005930920297L;
    private String className = null;
    private String libInstance1 = null;
    private String libInstance2 = null;
    
    MultipleInstanceException (String libClass, String instance1, String instance2) {
        super();
        className = libClass;
        libInstance1 = instance1;
        libInstance2 = instance2;
    }

    /* (non-Javadoc)
     * @see java.lang.Throwable#getMessage()
     */
    @Override
    public String getMessage() {
        // TODO Auto-generated method stub
        return " Library Class " + className + "is Produced by Two Instances: " 
            + libInstance1 + " and " + libInstance2 + ". Platform Build will Fail.";
    }
    
}

class ImproperInstanceException extends Exception {

    /**
     * 
     */
    private static final long serialVersionUID = -5279700566993277033L;
    private String className = null;
    private String libInstance = null;
    private String instanceSupArch = null;
    private String instanceSupModType = null;
    
    ImproperInstanceException (String libClass, String instance1, String arch, String type) {
        super();
        className = libClass;
        libInstance = instance1;
        instanceSupArch = arch;
        instanceSupModType = type;
    }

    /* (non-Javadoc)
     * @see java.lang.Throwable#getMessage()
     */
    @Override
    public String getMessage() {
        // TODO Auto-generated method stub
        return " Library Class " + className + " Produced by Library Instance: " 
            + libInstance + "\nOnly Supports " + instanceSupArch + " and Module Type " + instanceSupModType + ".\n This instance should be removed.\n";
    }
    
}

class NoInstanceException extends Exception {

    /**
     * 
     */
    private static final long serialVersionUID = 1987122786598970598L;
    
    private String className = null;
    
    NoInstanceException (String libClass) {
        className = libClass;
    }
    
    public String getMessage() {
        return "No Applicable Instance for Library Class " + className
            + ", Platform Build will Fail.";
    }
}