AvatarDesignPanel.java

/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
 * 
 * ludovic.apvrille AT enst.fr
 * 
 * This software is a computer program whose purpose is to allow the
 * edition of TURTLE analysis, design and deployment diagrams, to
 * allow the generation of RT-LOTOS or Java code from this diagram,
 * and at last to allow the analysis of formal validation traces
 * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
 * from INRIA Rhone-Alpes.
 * 
 * This software is governed by the CeCILL  license under French law and
 * abiding by the rules of distribution of free software.  You can  use,
 * modify and/ or redistribute the software under the terms of the CeCILL
 * license as circulated by CEA, CNRS and INRIA at the following URL
 * "http://www.cecill.info".
 * 
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 * 
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 * 
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL license and that you accept its terms.
 */

package ui;

import avatartranslator.*;
import myutil.GraphicLib;
import proverifspec.ProVerifOutputAnalyzer;
import proverifspec.ProVerifQueryAuthResult;
import proverifspec.ProVerifQueryResult;
import proverifspec.ProVerifResultTrace;
import ui.avatarbd.*;
import ui.avatardd.ADDDiagramPanel;
import ui.avatarsmd.AvatarSMDPanel;
import ui.avatarsmd.AvatarSMDState;
import ui.avatarsmd.AvatarSMDToolBar;
import ui.interactivesimulation.SimulationLatency;
import ui.util.IconManager;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.*;
import java.util.*;
import java.util.List;

/**
 * Class AvatarDesignPanel
 * Management of Avatar block panels
 * Creation: 06/04/2010
 *
 * @author Ludovic APVRILLE
 * @version 1.0 06/04/2010
 * @see MainGUI
 */
public class AvatarDesignPanel extends TURTLEPanel {

    public AvatarBDPanel abdp;

    public AvatarDesignPanel(MainGUI _mgui) {
        super(_mgui);
        if (_mgui == null) {
            //for unit testing only
            abdp = new AvatarBDPanel(null, null);
            return;
        }
        // Issue #41 Ordering of tabbed panes 
        //tabbedPane = GraphicLib.createTabbedPane();//new JTabbedPane();
        tabbedPane = GraphicLib.createDraggableEnhancedTabbedPaneFixedAt0(this);//new JTabbedPane();


        cl = new ChangeListener() {

            @Override
            public void stateChanged(ChangeEvent e) {
                mgui.paneDesignAction(e);
            }
        };

        tabbedPane.addChangeListener(cl);
        tabbedPane.addMouseListener(new TURTLEPanelPopupListener(this, mgui));
    }


    public void setValidated(List<AvatarBDStateMachineOwner> _validated) {
        if (abdp != null) {
            abdp.setValidated(_validated);
        }
    }

    public void setIgnored(List<AvatarBDStateMachineOwner> _ignored) {
        if (abdp != null) {
            abdp.setIgnored(_ignored);
        }
    }

    public void setOptimized(boolean _optimized) {
        if (abdp != null) {
            abdp.setOptimized(_optimized);
        }
    }

    public void setConsiderTimingOperators(boolean _considerTimingOperators) {
        if (abdp != null) {
            abdp.setConsiderTimingOperators(_considerTimingOperators);
        }
    }

    public List<AvatarBDStateMachineOwner> getValidated() {
        if (abdp != null) {
            return abdp.getValidated();
        }
        return null;
    }

    public List<AvatarBDStateMachineOwner> getIgnored() {
        if (abdp != null) {
            return abdp.getIgnored();
        }
        return null;
    }

    public boolean getOptimized() {
        if (abdp != null) {
            return abdp.getOptimized();
        }
        return true;
    }

    public boolean getConsiderTimingOperators() {
        if (abdp != null) {
            return abdp.getConsiderTimingOperators();
        }
        return true;
    }

    public AvatarBDPanel getAvatarBDPanel() {
        return abdp;
    }

    public AvatarSMDPanel getAvatarSMDPanel(String name) {
        AvatarSMDPanel asmdp;
        for (int i = 1; i < panels.size(); i++) {
            asmdp = (AvatarSMDPanel) (panels.elementAt(i));
            if (asmdp.getName().compareTo(name) == 0) {
                return asmdp;
            }
        }
        return null;
    }

    public void addAvatarStateMachineDiagramPanel(String s) {
        JPanel toolBarPanel = new JPanel();
        toolBarPanel.setLayout(new BorderLayout());

        AvatarSMDToolBar toolBarActivity = new AvatarSMDToolBar(mgui);
        toolbars.add(toolBarActivity);

        AvatarSMDPanel asmdp = new AvatarSMDPanel(mgui, toolBarActivity);
        asmdp.tp = this;
        asmdp.setName(s);
        JScrollDiagramPanel jsp = new JScrollDiagramPanel(asmdp);
        asmdp.jsp = jsp;
        jsp.setWheelScrollingEnabled(true);
        jsp.getVerticalScrollBar().setUnitIncrement(MainGUI.INCREMENT);
        toolBarPanel.add(toolBarActivity, BorderLayout.NORTH);
        toolBarPanel.add(jsp, BorderLayout.CENTER);
        panels.add(asmdp);
        tabbedPane.addTab(s, IconManager.imgic63, toolBarPanel, "Opens the state machine of " + s);
        //tabbedPane.setMnemonicAt(tabbedPane.getTabCount()-1, '^');
        return;
    }

    @Override
    public void init() {

        //  Class Diagram toolbar
        AvatarBDToolBar toolBarAvatarBD = new AvatarBDToolBar(mgui);
        toolbars.add(toolBarAvatarBD);

        toolBarPanel = new JPanel();
        toolBarPanel.setLayout(new BorderLayout());

        //Class diagram
        abdp = new AvatarBDPanel(mgui, toolBarAvatarBD);
        abdp.setName("Block Diagram");
        abdp.tp = this;
        tdp = abdp;
        panels.add(abdp); // Always first in list
        JScrollDiagramPanel jsp = new JScrollDiagramPanel(abdp);
        abdp.jsp = jsp;
        jsp.setWheelScrollingEnabled(true);
        jsp.getVerticalScrollBar().setUnitIncrement(MainGUI.INCREMENT);
        toolBarPanel.add(toolBarAvatarBD, BorderLayout.NORTH);
        toolBarPanel.add(jsp, BorderLayout.CENTER);
        tabbedPane.addTab("Design", IconManager.imgic80, toolBarPanel, "Opens the Design");
        tabbedPane.setSelectedIndex(0);
        //tabbedPane.setMnemonicAt(tabbedPane.getTabCount()-1, '^');
        mgui.changeMade(abdp, TDiagramPanel.NEW_COMPONENT);

        //jsp.setVisible(true);

    }

    public List<AvatarBDLibraryFunction> getAllLibraryFunctions(String _name) {
        return abdp.getAllLibraryFunctionsForBlock(_name);
    }

    public List<TAttribute> getAllAttributes(String _name) {
        return abdp.getAllAttributesOfBlock(_name);
    }

    public List<AvatarMethod> getAllMethods(String _name) {
        return abdp.getAllMethodsOfBlock(_name);
    }

    public List<AvatarSignal> getAllSignals(String _name) {
        return abdp.getAllSignalsOfBlock(_name);
    }

    public List<String> getAllTimers(String _name) {
        return abdp.getAllTimersOfBlock(_name);
    }

    @Override
    public String saveHeaderInXml(String extensionToName) {
        if (extensionToName == null) {
            return "<Modeling type=\"AVATAR Design\" nameTab=\"" + mgui.getTabName(this) + "\" tabs=\"" + getAllTabsName() + "\" >\n";
        }

        return "<Modeling type=\"AVATAR Design\" nameTab=\"" + mgui.getTabName(this) + extensionToName + "\" tabs=\"" + getAllTabsName() + "\" >\n";
    }

    @Override
    public String saveTailInXml() {
        return "</Modeling>\n\n\n";
    }

    @Override
    public String toString() {
        return mgui.getTitleAt(this) + " (Design)";
    }

    public void resetMetElements() {
        //TraceManager.addDev("Reset met elements");
        TGComponent tgc;

        for (int i = 0; i < panels.size(); i++) {
            Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
            while (iterator.hasNext()) {
                tgc = iterator.next();
                tgc.setAVATARMet(0);
                tgc.setInternalAvatarMet(0);

            }
        }

    }

    public List<TGComponent> getListOfComponentsInMutex() {
        TGComponent tgc;
        TDiagramPanel tdp;

        List<TGComponent> list = new LinkedList<TGComponent>();

        for (int i = 0; i < panels.size(); i++) {
            tdp = panels.get(i);
            if (tdp instanceof AvatarSMDPanel) {
                Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
                while (iterator.hasNext()) {
                    tgc = iterator.next();
                    tgc.getAllCheckableInvariant(list);
                }
            }
        }

        return list;

    }

    public TGComponent hasCheckableMasterMutex() {
        TGComponent tgc, tgctmp;
        for (int i = 0; i < panels.size(); i++) {
            tdp = panels.get(i);
            if (tdp instanceof AvatarSMDPanel) {
                Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
                while (iterator.hasNext()) {
                    tgc = iterator.next();
                    tgctmp = tgc.hasCheckableMasterMutex();
                    if (tgctmp != null) {
                        //TraceManager.addDev("Found element with master mutex: " + tgctmp);
                        return tgctmp;
                    }
                }
            }
        }

        return null;
    }

    public void removeAllMutualExclusionWithMasterMutex() {
        TGComponent tgc;
        for (int i = 0; i < panels.size(); i++) {
            tdp = panels.get(i);
            if (tdp instanceof AvatarSMDPanel) {
                Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
                while (iterator.hasNext()) {
                    tgc = iterator.next();
                    tgc.removeAllMutualExclusionWithMasterMutex();
                }
            }
        }
    }

    public void reinitMutualExclusionStates() {
        TGComponent tgc;
        for (int i = 0; i < panels.size(); i++) {
            tdp = panels.get(i);
            if (tdp instanceof AvatarSMDPanel) {
                Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
                while (iterator.hasNext()) {
                    tgc = iterator.next();
                    if (tgc instanceof AvatarSMDState) {
                        ((AvatarSMDState) tgc).reinitMutualExclusionStates();
                    }
                }
            }
        }
    }

    public void clearGraphicalInfoOnInvariants() {

    }

    public List<String> getPropertyPragmas() {
        List<String> result = new LinkedList<String>();
        for (Object tgc : abdp.getComponentList()) {
            if (tgc instanceof AvatarBDPragma) {
                result.addAll(((AvatarBDPragma) tgc).getProperties());
            }
        }

        return result;
    }

    public List<String> getModelPragmas() {
        List<String> result = new LinkedList<String>();
        for (Object tgc : abdp.getComponentList()) {
            if (tgc instanceof AvatarBDPragma) {
                result.addAll(((AvatarBDPragma) tgc).getModels());
            }
        }

        return result;
    }

    public void resetModelBacktracingProVerif() {
        if (abdp == null) {
            return;
        }

        // Reset confidential attributes
        for (AvatarBDBlock block1 : abdp.getFullBlockList()) {
            block1.resetConfidentialityOfAttributes();
        }
        for (Object tgc : abdp.getComponentList()) {
            if (tgc instanceof AvatarBDPragma) {
                AvatarBDPragma pragma = (AvatarBDPragma) tgc;
                pragma.authStrongMap.clear();
                pragma.authWeakMap.clear();

            }
        }
        // Reset reachable states
        for (int i = 0; i < panels.size(); i++) {
            tdp = panels.get(i);
            if (tdp instanceof AvatarSMDPanel) {
                ((AvatarSMDPanel) tdp).resetStateSecurityInfo();
            }
        }
    }


    public void modelBacktracingUppaal(Map<String, Integer> verifMap) {
        for (Object ob : abdp.getComponentList()) {
            if (ob instanceof AvatarBDSafetyPragma) {
                AvatarBDSafetyPragma pragma = (AvatarBDSafetyPragma) ob;
                pragma.verifMap = verifMap;
            }
        }
    }

    public void modelBacktracingLatency(Vector<SimulationLatency> latencies) {
        //Search for Safety Pragma
        for (Object ob : abdp.getComponentList()) {
            if (ob instanceof AvatarBDPerformancePragma) {
                AvatarBDPerformancePragma bdpragma = (AvatarBDPerformancePragma) ob;
                //Match each safety pragma to latency result
                for (String s : bdpragma.getProperties()) {
                    for (SimulationLatency latency : latencies) {
                        for (AvatarPragmaLatency pragma : latency.getPragmas()) {
                            if (pragma.getPragmaString().equals(s)) {
                                //Check if the latency statement is true
                                int refTime = pragma.getTime();
                                float time = 0;
                                //System.out.println("time " + latency.getAverageTime() + " " + refTime);
                                try {
                                    time = Float.valueOf(latency.getAverageTime());
                                } catch (Exception e) {
                                    continue;
                                }
                                if (pragma.getSymbolType() == AvatarPragmaLatency.lessThan) {
                                    if (time < refTime) {
                                        bdpragma.verifMap.put(s, "PROVED_TRUE");
                                        //mark as true
                                    } else {
                                        bdpragma.verifMap.put(s, "PROVED_FALSE");
                                    }
                                } else if (pragma.getSymbolType() == AvatarPragmaLatency.greaterThan) {
                                    if (time > refTime) {
                                        bdpragma.verifMap.put(s, "PROVED_TRUE");
                                        //mark as true
                                    } else {
                                        bdpragma.verifMap.put(s, "PROVED_FALSE");
                                    }
                                } else if (pragma.getSymbolType() == AvatarPragmaLatency.query) {
                                    //Draw average time on verif map
                                    bdpragma.verifMap.put(s, Float.toString(time));
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public void modelBacktracingProVerif(ProVerifOutputAnalyzer pvoa) {

        if (abdp == null) {
            return;
        }

        resetModelBacktracingProVerif();

        // Confidential attributes
        Map<AvatarPragmaSecret, ProVerifQueryResult> confResults = pvoa.getConfidentialityResults();
        Map<AvatarAttribute, AvatarPragma> secretAttributes = new HashMap<AvatarAttribute, AvatarPragma>();
        Map<AvatarAttribute, AvatarPragma> nonSecretAttributes = new HashMap<AvatarAttribute, AvatarPragma>();
        for (AvatarPragmaSecret pragma : confResults.keySet()) {
            ProVerifQueryResult result = confResults.get(pragma);
            if (result.isProved()) {
                if (result.isSatisfied())
                    secretAttributes.put(pragma.getArg(), pragma);
                else
                    nonSecretAttributes.put(pragma.getArg(), pragma);
            }
        }

        for (AvatarBDBlock bdBlock : abdp.getFullBlockList())
            for (TAttribute tattr : bdBlock.getAttributeList()) {
                if (tattr.getType() == TAttribute.OTHER) {
                    List<TAttribute> types = abdp.getAttributesOfDataType(tattr.getTypeOther());
                    int toBeFound = types.size();
                    boolean ko = false;
                    for (TAttribute type : types) {
                        for (AvatarAttribute attribute : secretAttributes.keySet())
                            if (attribute.getBlock().getName().equals(bdBlock.getBlockName()) && attribute.getName().equals(tattr.getId() + "__" + type.getId())) {
                                toBeFound--;
                                ProVerifResultTrace trace = confResults.get(secretAttributes.get(attribute)).getTrace();
                                if (trace != null) {
                                    bdBlock.addProVerifTrace(tattr, trace);
                                }
                                break;
                            }

                        for (AvatarAttribute attribute : nonSecretAttributes.keySet())
                            if (attribute.getBlock().getName().equals(bdBlock.getBlockName()) && attribute.getName().equals(tattr.getId() + "__" + type.getId())) {
                                ko = true;
                                ProVerifResultTrace trace = confResults.get(nonSecretAttributes.get(attribute)).getTrace();
                                if (trace != null) {
                                    bdBlock.addProVerifTrace(tattr, trace);
                                }
                                break;
                            }

                        if (ko)
                            break;
                    }

                    if (ko) {
                        tattr.setConfidentialityVerification(TAttribute.CONFIDENTIALITY_KO);

                    } else if (toBeFound == 0) {
                        tattr.setConfidentialityVerification(TAttribute.CONFIDENTIALITY_OK);

                    }
                } else {
                    for (AvatarAttribute attribute : secretAttributes.keySet())
                        if (attribute.getBlock().getName().equals(bdBlock.getBlockName()) && attribute.getName().equals(tattr.getId())) {
                            tattr.setConfidentialityVerification(TAttribute.CONFIDENTIALITY_OK);
                            ProVerifResultTrace trace = confResults.get(secretAttributes.get(attribute)).getTrace();
                            if (trace != null) {
                                bdBlock.addProVerifTrace(tattr, trace);
                            }
                        }
                    for (AvatarAttribute attribute : nonSecretAttributes.keySet())
                        if (attribute.getBlock().getName().equals(bdBlock.getBlockName()) && attribute.getName().equals(tattr.getId())) {
                            tattr.setConfidentialityVerification(TAttribute.CONFIDENTIALITY_KO);
                            ProVerifResultTrace trace = confResults.get(nonSecretAttributes.get(attribute)).getTrace();
                            if (trace != null) {
                                bdBlock.addProVerifTrace(tattr, trace);
                            }
                        }
                }
            }


        // Reachable states
        Map<AvatarPragmaReachability, ProVerifQueryResult> reachResults = pvoa.getReachabilityResults();
        for (AvatarPragmaReachability pragma : reachResults.keySet()) {
            ProVerifQueryResult result = reachResults.get(pragma);
            if (result.isProved()) {
                for (int i = 0; i < panels.size(); i++) {
                    tdp = panels.get(i);
                    if ((tdp instanceof AvatarSMDPanel) && (tdp.getName().compareTo(pragma.getBlock().getName()) == 0)) {
                        Iterator<TGComponent> iterator = panels.get(i).getComponentList().listIterator();
                        while (iterator.hasNext()) {
                            TGComponent tgc = iterator.next();
                            if (tgc instanceof AvatarSMDState) {
                                ((AvatarSMDState) tgc).setSecurityInfo(
                                        result.isSatisfied() ? AvatarSMDState.REACHABLE : AvatarSMDState.NOT_REACHABLE,
                                        pragma.getState().getName());
                            }
                        }

                        break;
                    }
                }
            }
        }

        Map<AvatarPragmaAuthenticity, ProVerifQueryAuthResult> authResults = pvoa.getAuthenticityResults();
        for (Object ob : abdp.getComponentList())
            if (ob instanceof AvatarBDPragma) {
                AvatarBDPragma pragma = (AvatarBDPragma) ob;
                for (String prop : pragma.getProperties()) {
                    String[] split = prop.trim().split("\\s+");
                    if (split.length != 3)
                        continue;
                    if (split[0].equals("#Authenticity")) {
                        String[] argA = split[1].split("\\.");
                        String[] argB = split[2].split("\\.");

                        if (argA.length != 3 || argB.length != 3)
                            continue;

                        TAttribute tattrA = abdp.getAttributeByBlockName(argA[0], argA[2]);
                        TAttribute tattrB = abdp.getAttributeByBlockName(argB[0], argB[2]);

                        if (tattrA == null || tattrB == null)
                            continue;

                        if (tattrA.getType() != tattrB.getType())
                            continue;

                        if (tattrA.getType() == TAttribute.OTHER) {
                            if (!tattrA.getTypeOther().equals(tattrB.getTypeOther()))
                                continue;

                            List<TAttribute> types = abdp.getAttributesOfDataType(tattrA.getTypeOther());
                            int toBeFound = types.size();
                            boolean ko = false;
                            boolean weakKo = false;
                            boolean isNotProved = false;
                            boolean weakIsNotProved = false;
                            ProVerifQueryAuthResult result = new ProVerifQueryAuthResult(false, false);
                            for (TAttribute type : types) {
                                for (AvatarPragmaAuthenticity pragmaAuth : authResults.keySet()) {
                                    if (!pragmaAuth.getAttrA().getAttribute().getBlock().getName().equals(argA[0].replaceAll("\\.", "__"))
                                            || !pragmaAuth.getAttrB().getAttribute().getBlock().getName().equals(argB[0].replaceAll("\\.", "__"))
                                            || !pragmaAuth.getAttrA().getAttribute().getName().equals(argA[2] + "__" + type.getId())
                                            || !pragmaAuth.getAttrB().getAttribute().getName().equals(argB[2] + "__" + type.getId())
                                            || !pragmaAuth.getAttrA().getState().getName().equals(argA[1].replaceAll("\\.", "__"))
                                            || !pragmaAuth.getAttrB().getState().getName().equals(argB[1].replaceAll("\\.", "__")))
                                        continue;

                                    result = authResults.get(pragmaAuth);
                                    toBeFound--;

                                    if (result.isProved()) {
                                        if (!result.isSatisfied()) {
                                            ko = true;
                                        }
                                    } else {
                                        isNotProved = true;
                                    }

                                    if (result.isWeakProved()) {
                                        if (!result.isWeakSatisfied()) {
                                            weakKo = true;
                                        }
                                    } else {
                                        weakIsNotProved = true;
                                    }

                                    break;
                                }
                            }

                            if (ko)
                                pragma.authStrongMap.put(prop, 2);
                            else if (toBeFound == 0) {
                                if (isNotProved)
                                    pragma.authStrongMap.put(prop, 3);
                                else
                                    pragma.authStrongMap.put(prop, 1);
                            }

                            if (weakKo)
                                pragma.authWeakMap.put(prop, 2);
                            else if (toBeFound == 0) {
                                if (weakIsNotProved)
                                    pragma.authWeakMap.put(prop, 3);
                                else
                                    pragma.authWeakMap.put(prop, 1);
                            }
                            ProVerifResultTrace trace = result.getTrace();
                            if (trace != null) {
                                pragma.pragmaTraceMap.put(prop, trace);
                            }
                        } else {
                            for (AvatarPragmaAuthenticity pragmaAuth : authResults.keySet()) {
                                if (!pragmaAuth.getAttrA().getAttribute().getBlock().getName().equals(argA[0].replaceAll("\\.", "__"))
                                        || !pragmaAuth.getAttrB().getAttribute().getBlock().getName().equals(argB[0].replaceAll("\\.", "__"))
                                        || !pragmaAuth.getAttrA().getAttribute().getName().equals(argA[2])
                                        || !pragmaAuth.getAttrB().getAttribute().getName().equals(argB[2])
                                        || !pragmaAuth.getAttrA().getState().getName().equals(argA[1].replaceAll("\\.", "__"))
                                        || !pragmaAuth.getAttrB().getState().getName().equals(argB[1].replaceAll("\\.", "__")))
                                    continue;

                                ProVerifQueryAuthResult result = authResults.get(pragmaAuth);

                                if (result.isProved()) {
                                    if (result.isSatisfied()) {
                                        pragma.authStrongMap.put(prop, 1);
                                    } else {
                                        pragma.authStrongMap.put(prop, 2);
                                    }
                                } else {
                                    pragma.authStrongMap.put(prop, 3);
                                }

                                if (result.isWeakProved()) {
                                    if (result.isWeakSatisfied()) {
                                        pragma.authWeakMap.put(prop, 1);
                                    } else {
                                        pragma.authWeakMap.put(prop, 2);
                                    }
                                } else {
                                    pragma.authWeakMap.put(prop, 3);
                                }
                                //Add ProVerif Result Trace to pragma
                                ProVerifResultTrace trace = pvoa.getResults().get(pragmaAuth).getTrace();
                                if (trace != null) {
                                    pragma.pragmaTraceMap.put(prop, trace);
                                }
                                break;
                            }
                        }
                    }
                }
            }
    }

    public List<String> getAllNonMappedAvatarBlockNames(String _name, ADDDiagramPanel _tadp, boolean ref, String name) {
        return abdp.getAllNonMappedAvatarBlockNames(_name, _tadp, ref, name);
    }

    public List<String> getAllNonMappedAvatarChannelNames(String _name, ADDDiagramPanel _tadp, boolean ref, String name) {
        return abdp.getAllNonMappedAvatarChannelNames(_name, _tadp);
    }
}