Made CodeSnippetSupplier generic
[Mograsim.git] / net.mograsim.logic.ui / src / net / mograsim / logic / ui / serializing / CodeSnippetSupplier.java
index abd0e73..453e2ac 100644 (file)
@@ -5,123 +5,106 @@ import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
 
-import com.google.gson.JsonElement;
-
-import net.haspamelodica.swt.helper.swtobjectwrappers.Point;
-import net.haspamelodica.swt.helper.swtobjectwrappers.Rectangle;
-import net.mograsim.logic.ui.serializing.snippets.Renderer;
 import net.mograsim.logic.ui.serializing.snippets.RendererProvider;
+import net.mograsim.logic.ui.serializing.snippets.outlinerenderers.DefaultOutlineRendererProvider;
+import net.mograsim.logic.ui.serializing.snippets.symbolrenderers.DefaultSymbolRendererProvider;
 import net.mograsim.logic.ui.util.JsonHandler;
-import net.mograsim.preferences.ColorDefinition;
-import net.mograsim.preferences.ColorManager;
-import net.mograsim.preferences.Preferences;
 
-public class CodeSnippetSupplier
+public class CodeSnippetSupplier<S>
 {
-       private static final Map<String, String> standardSnippetIDClassNames = new HashMap<>();
-
-       private static final Map<String, RendererProvider> outlineRendererProvidersForComponentClassNames = new HashMap<>();
-       private static final Map<String, RendererProvider> symbolRendererProvidersForComponentClassNames = new HashMap<>();
+       // public static members
+       public static final CodeSnippetSupplier<RendererProvider> symbolRendererProviderSupplier;
+       public static final CodeSnippetSupplier<RendererProvider> outlineRendererProviderSupplier;
 
-       private static final RendererProvider defaultOutlineRendererProvider;
-       private static final RendererProvider defaultSymbolRendererProvider;
        static
        {
-               // TODO this code does not belong here
-               defaultOutlineRendererProvider = (comp, params) -> (gc, visReg) ->
-               {
-                       ColorDefinition fg = Preferences.current().getColorDefinition("net.mograsim.logic.ui.color.foreground");
-                       if (fg != null)
-                               gc.setForeground(ColorManager.current().toColor(fg));
-                       gc.drawRectangle(comp.getBounds());
-               };
-               defaultSymbolRendererProvider = (comp, params) -> (gc, visReg) ->
-               {
-                       ColorDefinition fg = Preferences.current().getColorDefinition("net.mograsim.logic.ui.color.text");
-                       if (fg != null)
-                               gc.setForeground(ColorManager.current().toColor(fg));
-                       String id = "TODO";// TODO add an ID of sorts to DeserializedSubmodelComponent
-                       Point idSize = gc.textExtent(id);
-                       Rectangle bounds = comp.getBounds();
-                       gc.drawText(id, bounds.x + (bounds.width - idSize.x) / 2, bounds.y + (bounds.height - idSize.y) / 2, true);
-               };
+               symbolRendererProviderSupplier = new CodeSnippetSupplier<>(new DefaultSymbolRendererProvider());
+               outlineRendererProviderSupplier = new CodeSnippetSupplier<>(new DefaultOutlineRendererProvider());
        }
 
-       static
-       {
-               try (InputStream s = IndirectGUIComponentCreator.class.getResourceAsStream("./mapping.json"))
-               {
-                       if (s == null)
-                               throw new IOException("Resource not found");
-                       Map<String, String> tmp = JsonHandler.readJson(s, Map.class);
-                       standardSnippetIDClassNames.putAll(tmp);
-               }
-               catch (IOException e)
-               {
-                       System.err.println("Failed to initialize standard snippet ID mapping: " + e.getMessage());
-               }
-       }
+       // per-instance members
 
-       public static void addStandardSnippetID(String standardSnippetID, String associatedSnippetClassName)
-       {
-               standardSnippetIDClassNames.put(standardSnippetID, associatedSnippetClassName);
-       }
+       private final Map<String, String> standardSnippetIDClassNames = new HashMap<>();
+       private final Map<String, S> snippetProvidersForClassNames = new HashMap<>();
+       private final S defaultSnippetProvider;
 
-       public static void setOutlineRendererProvider(String id, RendererProvider outlineRendererProvider)
+       private CodeSnippetSupplier(S defaultSnippetProvider)
        {
-               outlineRendererProvidersForComponentClassNames.put(id, outlineRendererProvider);
+               this.defaultSnippetProvider = defaultSnippetProvider;
        }
 
-       public static void setSymbolRendererProvider(String id, RendererProvider symbolRendererProvider)
+       public void addStandardSnippetID(String standardSnippetID, String associatedSnippetClassName)
        {
-               symbolRendererProvidersForComponentClassNames.put(id, symbolRendererProvider);
-       }
-
-       public static Renderer createOutlineRenderer(String id, DeserializedSubmodelComponent component, JsonElement params)
-       {
-               return getSnippet(id, outlineRendererProvidersForComponentClassNames, defaultOutlineRendererProvider).create(component, params);
+               standardSnippetIDClassNames.put(standardSnippetID, associatedSnippetClassName);
        }
 
-       public static Renderer createSymbolRenderer(String id, DeserializedSubmodelComponent component, JsonElement params)
+       public void setSnippetProvider(String id, S snippetProvider)
        {
-               return getSnippet(id, symbolRendererProvidersForComponentClassNames, defaultSymbolRendererProvider).create(component, params);
+               snippetProvidersForClassNames.put(id, snippetProvider);
        }
 
        // TODO report errors
-       private static <C> C getSnippet(String id, Map<String, C> specializedCodeMap, C defaultSnippet)
+       public S getSnippetProvider(String id)
        {
                if (id != null)
                {
-                       String snippetClassName;
+                       String snippetProviderClassName;
                        if (id.startsWith("class:"))
-                               snippetClassName = id.substring(6);
+                               snippetProviderClassName = id.substring(6);
                        else
-                               snippetClassName = standardSnippetIDClassNames.get(id);
-                       if (snippetClassName != null)
+                               snippetProviderClassName = standardSnippetIDClassNames.get(id);
+                       if (snippetProviderClassName != null)
                        {
-                               tryLoadSnippetClass(snippetClassName);
-                               C specializedCode = specializedCodeMap.get(snippetClassName);
-                               if (specializedCode != null)
-                                       return specializedCode;
+                               tryLoadSnippetClass(snippetProviderClassName);
+                               S snippetProvider = snippetProvidersForClassNames.get(snippetProviderClassName);
+                               if (snippetProvider != null)
+                                       return snippetProvider;
                        }
                }
-               return defaultSnippet;
+               System.err.println("Couldn't load snippet " + id + "; using default");
+               return defaultSnippetProvider;
+       }
+
+       // static helpers
+
+       static
+       {
+               try (InputStream s = IndirectGUIComponentCreator.class.getResourceAsStream("./standardSnippetIDMapping.json"))
+               {
+                       if (s == null)
+                               throw new IOException("Resource not found");
+                       SnippetIDClassNames tmp = JsonHandler.readJson(s, SnippetIDClassNames.class);
+                       tmp.standardOutlineRendererProviders.forEach(outlineRendererProviderSupplier::addStandardSnippetID);
+                       tmp.standardSymbolRendererProviders.forEach(symbolRendererProviderSupplier::addStandardSnippetID);
+               }
+               catch (Exception e)
+               {
+                       System.err.println("Failed to initialize standard snippet ID mapping: ");
+                       e.printStackTrace();
+               }
+       }
+
+       private static class SnippetIDClassNames
+       {
+               public Map<String, String> standardOutlineRendererProviders;
+               public Map<String, String> standardSymbolRendererProviders;
        }
 
        private static void tryLoadSnippetClass(String snippetClassName)
        {
-               tryLoadClass(snippetClassName, "Error getting snippet code for component class: %s\n");
+               tryInvokeStaticInitializer(snippetClassName, "Error getting snippet class: %s: %s\n");
        }
 
-       public static void tryLoadClass(String className, String errorMessageFormat)
+       public static void tryInvokeStaticInitializer(String className, String errorMessageFormat)
        {
                try
                {
-                       CodeSnippetSupplier.class.getClassLoader().loadClass(className);
+                       Class.forName(className, true, CodeSnippetSupplier.class.getClassLoader());
                }
-               catch (@SuppressWarnings("unused") ClassNotFoundException e)
+               catch (ClassNotFoundException e)
                {
-                       System.err.printf(errorMessageFormat, className);
+                       System.err.printf(errorMessageFormat, className, "ClassNotFoundException thrown: " + e.getMessage());
                }
        }
+
 }
\ No newline at end of file