Language.java

gehe zur Dokumentation dieser Datei

package de.lathanda.eos.config;
 
import java.awt.event.ActionListener;
import java.util.Collection;
import java.util.LinkedList;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
 
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
 
import de.lathanda.eos.base.util.GuiToolkit;
import de.lathanda.eos.baseparser.AutoCompleteEntry;
import de.lathanda.eos.baseparser.SystemFunctionType;
import de.lathanda.eos.baseparser.SystemMethodType;
import de.lathanda.eos.baseparser.SystemType;
import de.lathanda.eos.baseparser.Type;
import de.lathanda.eos.baseparser.UserType;
import de.lathanda.eos.config.Help.HelpPage;
import de.lathanda.eos.vm.MissingTypeException;
import de.lathanda.eos.vm.ReservedVariables;
 
 
public class Language {
    public static Language def = new Language();
    private TreeMap<String, LanguageConfig> langs = new TreeMap<>();
    private LanguageConfig effectiv;
    private final TreeSet<AutoCompleteEntry> templates = new TreeSet<>();
    private final TreeMap<String, String> labels = new TreeMap<>();
    private Help helpEntries;
 
    private LangFlags flags = new LangFlags();
    private Language() {
        init();
    }
    private void init() {
        flags = new LangFlags();
        effectiv = new LanguageConfig("effectiv", flags);
        LangXMLScanner lxs = new LangXMLScanner(this);
        lxs.load();
    }
 
    public Collection<LanguageConfig> getAvailableLanguageConfigs() {
        return langs.values();
    }
    public boolean isLockProperties() {
        return flags.isLockProperties();
    }
    public void setLockProperties(boolean lockProperties) {
        this.flags.setLockProperties(lockProperties);
    }
 
    public void registerLabels(ResourceBundle res) {
        for (String key : res.keySet()) {
            labels.put(key, res.getString(key));
        }
    }
 
    public boolean containsLabel(String id) {
        return labels.containsKey(id);
    }
 
    public String getLabel(String id) {
        return labels.getOrDefault(id, id);
    }   
    public String getClassLabelForID(String id) {
        LangClass lc = effectiv.getLangClass(id);
        if (lc != null) {
            return lc.label;
        } else {
            return id;
        }
    }
    public String getClassLabel(Type t) {
        if (t instanceof SystemType) {
            return getLangClassByID(t.getID()).label; 
        } else if (t instanceof UserType){
            return ((UserType)t).getLabel();
        } else {
            return t.getID();
        }
    }
    public LanguageConfig getOrCreateLanguageConfig(String extid) {
        LanguageConfig lc;
        if (langs.containsKey(extid)) {
            lc = langs.get(extid);
        } else {
            lc = new LanguageConfig(extid, flags);
            langs.put(lc.getID(), lc);
        }
 
        return lc;
    }
    public void addPluginMenues(JMenuBar mainMenu) {
        TreeMap<String, JMenuItem> menues = new TreeMap<>();
        for(LangMenuItem lmi : effectiv.getMenuItems()) {
            ActionListener al;
            try {
                al = (lmi.action == null || lmi.action.isEmpty())?null:(ActionListener)Class.forName(lmi.action).getDeclaredConstructor().newInstance();
                if (lmi.pid != null && !lmi.pid.isEmpty()) {
                    JMenuItem mi = GuiToolkit.createMenuItem(lmi.label, lmi.tooltip, al);
                    menues.put(lmi.id, mi);
                } else {
                    JMenu mi = GuiToolkit.createMenue(lmi.label);
                    mainMenu.add(mi);
                    menues.put(lmi.id, mi);                 
                }
            } catch (Exception e) {
                JOptionPane.showMessageDialog(null,
                        "class not found " + lmi.action,
                        "fatal error", JOptionPane.OK_OPTION);
                System.exit(-1);
            }
        }
        for(LangMenuItem lmi : effectiv.getMenuItems()) {
            if (lmi.pid != null && !lmi.pid.isEmpty()) {
                menues.get(lmi.pid).add(menues.get(lmi.id));
            }
        }
    }
    public void registerClass(String id, String pid, String javaclass) {
        LangClass lc = effectiv.getOrCreateLangClass(id);
        lc.pid = pid;
        lc.javaclass = javaclass;   
    }
    public void registerProperty(String cls_id, String property_id, String type, String getter, String setter, String view) {
        LangClass lc = effectiv.getOrCreateLangClass(cls_id);
        LangProperty lp = lc.getOrCreateProperty(property_id);
        lp.type = type;
        lp.getter = getter;
        lp.setter = setter;
        lp.view = view;
    }
    public void registerMethod(String cls_id, String method_id, String javamethod, LinkedList<String> parametertypes, String return_type) {
        LangClass lc = effectiv.getOrCreateLangClass(cls_id);
        LangMethod lm = lc.getOrCreateMethod(method_id);
        lm.javamethod = javamethod;
        for(String paratype : parametertypes) {
            LangParameter lpa = new LangParameter();
            lpa.type = paratype;
            lm.parameters.add(lpa);
        }       
        lm.ret = return_type;
    }
    public void registerModule(String id, String javaclass) {
        try {
            LangModule lm = effectiv.getOrCreateLangModule(id);
            lm.cls = Class.forName(javaclass);
        } catch (ClassNotFoundException e) {
            JOptionPane.showMessageDialog(null,
                    "class not found " + javaclass,
                    "fatal error", JOptionPane.OK_OPTION);
            System.exit(-1);
        }
    }
    public void registerGlobalFunction(String module_id, String function_id, String javamethod, LinkedList<String> parametertypes, String return_type) {
        LangModule lm = effectiv.getOrCreateLangModule(module_id);
        LangFunction lf = lm.getOrCreateFunction(function_id);
        lf.ret = return_type;
        lf.javamethod = javamethod;
        for(String paratype : parametertypes) {
            LangParameter lpa = new LangParameter();
            lpa.type = paratype;
            lf.parameters.add(lpa);
        }
    }
    public Collection<HelpPage> getHelpData() {
        return helpEntries.getHelpPages().values();
    }
    public Set<AutoCompleteEntry> getTemplates() {
        return templates;
    }
 
    public void registerHelp(Help help) {
        helpEntries = help;     
    }
 
    public void apply(LanguageConfig lc) {
        effectiv = lc.mergeSystem(effectiv);
        try {
            initSystem();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(null,
                e.getLocalizedMessage() ,
                "fatal error", JOptionPane.OK_OPTION);
            e.printStackTrace();
            System.exit(-1);
        }
    }
    public LangClass getLangClassByID(String id) {
        return effectiv.getOrCreateLangClass(id);
    }
 
    private void initSystem() throws NoSuchMethodException, MissingTypeException, ClassNotFoundException {
        ObjectFactory objf = new ObjectFactory();
        //create types
        for(LangClass lc : effectiv.getClasses()) {
            try {
                lc.type = SystemType.registerType(lc.id, lc.scan, objf.getObjectSource(lc), Class.forName(lc.javaclass));
            } catch (ClassNotFoundException e) {
                JOptionPane.showMessageDialog(null,
                        "class not found " + lc.javaclass,
                        "fatal error", JOptionPane.OK_OPTION);
                System.exit(-1);
            }
        }
        //link inheritance
        for(LangClass lc : effectiv.getClasses()) {
            if (lc.pid != null && !lc.pid.isEmpty()) {
                SystemType.registerSuper(lc.id, lc.pid);
            }
        }
        //create getters and setters for properties
        for(LangClass lc:effectiv.getClasses()) {
            for(LangProperty lp:lc.properties.values()) {
                if (lp.getter != null && !lp.getter.isEmpty()) {
                    //getter
                    lc.type.registerReadProperty(
                        new SystemMethodType(lp.id, lc.type, new SystemType[] {}, SystemType.getInstanceByID(lp.type), lp.getter, lp.label),
                        lp.label
                    );
                    //setter
                    lc.type.registerAssignProperty(
                        new SystemMethodType(lp.id, lc.type, new SystemType[] {SystemType.getInstanceByID(lp.type)}, SystemType.getVoid(), lp.setter, lp.label),
                        lp.label
                    );                  
                }
                //reader (read access to property for object cards or other diagrams, this can include invisible properties)
                lc.type.registerViewProperty(
                    lp.view,
                    lp.label
                );
            }           
        }
        //create methods
        for(LangClass lc:effectiv.getClasses()) {
            for(LangMethod lm:lc.methods.values()) {
                SystemType[] parameters = new SystemType[lm.parameters.size()];
                int i = 0;
                for(LangParameter lpa:lm.parameters) {
                    parameters[i++] = SystemType.getInstanceByID(lpa.type);
                    
                }
                lc.type.registerMethod(new SystemMethodType(lm.id, lc.type, parameters, SystemType.getInstanceByID(lm.ret), lm.javamethod, lm.label));              
            }
        }       
        //create functions
        for(LangModule lm:effectiv.getModules()) {      
            lm.cls = Class.forName(lm.javaclass);
            for(LangFunction lf:lm.functions.values()) {
                SystemType[] parameters = new SystemType[lf.parameters.size()];
                int i = 0;
                for(LangParameter lpa:lf.parameters) {
                    parameters[i++] = SystemType.getInstanceByID(lpa.type);
                    
                }
                SystemFunctionType.registerSystemFunction(lm.cls, parameters, SystemType.getInstanceByID(lf.ret), lf.javamethod, lf.label);             
            }
        }   
    }
    public String getDefaultWindowName() {
        return getLabel(ReservedVariables.WINDOW);
    }
}