Cleanup of theme code

glass-config-init/glass_config_init/theme.yml

@@ -1,3 +1,4 @@
-name: glass_theme.default.Theme
-args:
+glass_theme.splash.SplashAnimation:
   latlon: [70., 18.]
+  theme:
+    glass_theme.default.Theme:

glass-theme/glass_theme/__init__.py

@@ -7,7 +7,7 @@
 import re
 import os.path
 import yaml
-import importlib
+from .utils import instantiate_config
 
 @InfiniteGlass.profilable
 def main(*arg, **kw):
@@ -19,12 +19,8 @@ def main(*arg, **kw):
             with open(configpath) as f:
                 config = yaml.load(f, Loader=yaml.SafeLoader)
 
-        module_name, cls_name = config["name"].rsplit(".", 1)
-        module = importlib.import_module(module_name)
-        importlib.reload(module)
-        cls = getattr(module, cls_name)
-
-        cls(display, **config.get("args", {}))
+        theme = instantiate_config(display, None, config)
+        theme.activate()
         display.flush()
 
-        InfiniteGlass.DEBUG("init", "Theme started: %s\n" % config["name"])
+        InfiniteGlass.DEBUG("init", "Theme started: %s\n" % theme)

glass-theme/glass_theme/base.py

@@ -1,43 +1,33 @@
 import InfiniteGlass
-import pkg_resources
-import json
-import numpy
-import Xlib.X
-import sys
 import re
-import os.path
+from .utils import instantiate_config, read_file
 
 class ThemeBase(object):
     def __init__(self, display, **kw):
         self.display = display
+
+        recurse = set([name for name, value in kw.items()
+                       if isinstance(value, dict)
+                       ]).union(
+                           [name for name in dir(self)
+                            if (not name.startswith("__")
+                                and isinstance(getattr(self, name), type)
+                                and issubclass(getattr(self, name), ThemeBase))])
+        for name in recurse:
+            print("Recursing", self, name, getattr(self, name, None))
+            setattr(
+                self,
+                name,
+                instantiate_config(
+                    display,
+                    getattr(self, name, None),
+                    kw.pop(name, {})))
+
         for name, value in kw.items():
             setattr(self, name, value)
-        self.setup_shaders()
-        self.setup_properties()
-
-    shader_path = None
-    shaders = ("DEFAULT", "DECORATION", "ROOT", "SPLASH", "SPLASH_BACKGROUND")
-    shader_parts = ("GEOMETRY", "VERTEX", "FRAGMENT")
-
-    root_IG_SHADER = "IG_SHADER_ROOT"
 
-    root_IG_VIEW_SPLASH_LAYER = "IG_LAYER_SPLASH"
-    root_IG_VIEW_SPLASH_VIEW = [0.0, 0.0, 1.0, 0.0]
-    root_IG_VIEW_SPLASH_BACKGROUND_LAYER = "IG_LAYER_SPLASH_BACKGROUND"
-    root_IG_VIEW_SPLASH_BACKGROUND_VIEW = [0.0, 0.0, 1.0, 0.0]
-
-    root_IG_VIEW_MENU_LAYER = "IG_LAYER_MENU"
-    root_IG_VIEW_MENU_VIEW = [0.0, 0.0, 1.0, 0.0]
-    root_IG_VIEW_OVERLAY_LAYER = "IG_LAYER_OVERLAY"
-    root_IG_VIEW_OVERLAY_VIEW = [0.0, 0.0, 1.0, 0.0]
-    root_IG_VIEW_DESKTOP_LAYER = ["IG_LAYER_ISLAND", "IG_LAYER_DESKTOP"]
-    root_IG_VIEW_DESKTOP_VIEW = [0.0, 0.0, 1.0, 0.0]
-
-    root_IG_VIEW_ROOT_LAYER = "IG_LAYER_ROOT"
-    root_IG_VIEW_ROOT_VIEW = [0.0, 0.0, 1.0, 0.0]
-
-    root_IG_VIEWS = ["IG_VIEW_ROOT", "IG_VIEW_DESKTOP", "IG_VIEW_OVERLAY", "IG_VIEW_MENU"]
-
+    shaders_path = None
+    shaders_parts = ("GEOMETRY", "VERTEX", "FRAGMENT")
 
     def load_shader(self, name):
         defines = ''.join(
@@ -54,41 +44,43 @@ def load_shader(self, name):
         return preamble + defines + src
 
     def _load_shader(self, name):
-        if name.startswith("resource://"):
-            pkg, name = name.split("://")[1].split("/", 1)
-            with pkg_resources.resource_stream(pkg, name) as f:
-                src = f.read()
-        else:
-            with open(name) as f:
-                src = f.read()
+        src = read_file(name)
         includes = re.findall(rb'^#include  *"(.*)"', src, re.MULTILINE)
         for name in includes:
             src = re.sub(rb'#include  *"%s"' % (name,), self._load_shader(name.decode("utf-8")), src, re.MULTILINE)
         return src
 
     def get_shader(self, SHADER, PART):
-        part_name = "shader_%s_%s" % (SHADER, PART)
+        part_name = "shader_%s__%s" % (SHADER, PART)
         shader_name = "shader_%s" % (SHADER,)
-        if hasattr(self, part_name):
+        if getattr(self, part_name, None) is not None:
             part = getattr(self, part_name)
-        elif hasattr(self, shader_name):
+        elif getattr(self, shader_name, None) is not None:
             part = "%s/%s" % (getattr(self, shader_name), PART.lower())
         else:
             part = "%s/%s" % (SHADER.lower(), PART.lower())
         if "." not in part.split("/")[-1]:
             part = "%s.glsl" % (part,)
         if "://" not in part and not part.startswith("./") and not part.startswith("../") and not part.startswith("~"):
-            part = "%s/%s" % (self.shader_path, part)
-        part = os.path.expanduser(part)            
+            part = "%s/%s" % (self.shaders_path, part)
         return part
 
-    def setup_shaders(self):
-        for SHADER in self.shaders:
-            for PART in self.shader_parts:
+    def activate_shaders(self):
+        shaders = set()
+        for name in dir(self):
+            if name.startswith("shader_"):
+                shaders.add(name[len("shader_"):].split("__")[0])
+
+        for SHADER in shaders:
+            for PART in self.shaders_parts:
                 self.display.root["IG_SHADER_%s_%s" % (SHADER, PART)] = self.load_shader(self.get_shader(SHADER, PART))
-        self.display.root["IG_SHADERS"] = ["IG_SHADER_%s" % shader for shader in self.shaders]
+        self.display.root["IG_SHADERS"] = ["IG_SHADER_%s" % shader for shader in shaders]
 
-    def setup_properties(self):
+    def activate_properties(self):
         for name in dir(self):
             if name.startswith("root_"):
                 self.display.root[name[len("root_"):]] = getattr(self, name)
+
+    def activate(self):
+        self.activate_shaders()
+        self.activate_properties()

glass-theme/glass_theme/default.py

@@ -1,34 +1,36 @@
 import InfiniteGlass
-import pkg_resources
-import json
-import numpy
-import Xlib.X
-import sys
-import re
-import glass_theme.base
+from . import base
 
-class Theme(glass_theme.base.ThemeBase):
-    def __init__(self, *args, **kw):
-        glass_theme.base.ThemeBase.__init__(self, *args, **kw)
+class Theme(base.ThemeBase):
+    def activate(self):
+        base.ThemeBase.activate(self)
 
-        if "IG_THEME" in self.display.root:
-            del self.display.root["IG_THEME"]
-
-        if self.mode == "no_splash":
-            self.display.root["IG_VIEWS"] = ["IG_VIEW_ROOT", "IG_VIEW_DESKTOP", "IG_VIEW_OVERLAY", "IG_VIEW_MENU"]
-        elif self.mode == "splash_test":
-            self.setup_splash_test()
-        else:
-            self.setup_splash_animation()
-
-    mode = "splash"
-
-    root_IG_VIEWS = ["IG_VIEW_SPLASH_BACKGROUND", "IG_VIEW_SPLASH"]
-    shader_path = "resource://glass_theme/shaders"
+    shaders_path = "resource://glass_theme/shaders"
+
+    shader_DEFAULT = None
+    shader_DECORATION = None
     shader_ROOT = "root-fractal-julia"
-    latlon = (70., 18.)
-    start_latlon = None
 
+    root_IG_SHADER = "IG_SHADER_ROOT"
+
+    root_IG_VIEW_MENU_LAYER = "IG_LAYER_MENU"
+    root_IG_VIEW_MENU_VIEW = [0.0, 0.0, 1.0, 0.0]
+    root_IG_VIEW_OVERLAY_LAYER = "IG_LAYER_OVERLAY"
+    root_IG_VIEW_OVERLAY_VIEW = [0.0, 0.0, 1.0, 0.0]
+    root_IG_VIEW_DESKTOP_LAYER = ["IG_LAYER_ISLAND", "IG_LAYER_DESKTOP"]
+    root_IG_VIEW_DESKTOP_VIEW = [0.0, 0.0, 1.0, 0.0]
+
+    root_IG_VIEW_ROOT_LAYER = "IG_LAYER_ROOT"
+    root_IG_VIEW_ROOT_VIEW = [0.0, 0.0, 1.0, 0.0]
+
+    root_IG_VIEWS = ["IG_VIEW_ROOT",
+                     "IG_VIEW_DESKTOP",
+                     "IG_VIEW_OVERLAY",
+                     "IG_VIEW_MENU"]
+
+    root_IG_COLOR_TRANSFORM = 1
+
+
     define_EDGE_HINT_WIDTH = 4
     define_EDGE_HINT_COLOR = "vec4(0., 0., 0., 0.3)"
 
@@ -79,97 +81,4 @@ def __init__(self, *args, **kw):
                                 "0.0, 0.0, 1.0, 0.0," +
                                 "0.0, 0.0, 0.0, 1.0" +
                                 "))")
-
-    root_IG_COLOR_TRANSFORM = 1
 
-    def linestrings2texture(self, f):
-        coastline = json.load(f)
-
-        size = 0
-        for feature in coastline["features"]:
-            size += len(feature["geometry"]["coordinates"])
-
-        res = []
-        for feature in coastline["features"]:
-            coords = feature["geometry"]["coordinates"]
-            coords = list(zip(coords[:-1], coords[1:]))
-            res.extend([z for x in coords for y in x for z in y])
-
-        return res
-
-    def setup_splash(self):
-        w1 = self.display.root.create_window(map=False)
-        w1["WM_NAME"] = b"splash"
-        w1["IG_LAYER"] = "IG_LAYER_SPLASH"
-        w1["IG_SHADER"] = "IG_SHADER_SPLASH"
-        w1["IG_DRAW_TYPE"] = "IG_DRAW_TYPE_LINES"
-        with pkg_resources.resource_stream("glass_theme", "coastline50.geojson") as f:
-            w1["IG_COASTLINE"] = self.linestrings2texture(f)
-        w1.map()
-
-        w2 = self.display.root.create_window(map=False)
-        w2["WM_NAME"] = b"splash-background"
-        w2["IG_LAYER"] = "IG_LAYER_SPLASH_BACKGROUND"
-        w2["IG_SHADER"] = "IG_SHADER_SPLASH_BACKGROUND"
-        w2.map()
-
-        self.display.root["IG_WORLD_ALPHA"] = 1.
-
-        self.display.flush()
-
-        return w1, w2
-
-    def setup_splash_animation(self):
-        lat, lon = self.latlon
-
-        if self.start_latlon is not None:
-            start_lat, start_lon = self.start_latlon
-        else:
-            start_lat = lat - 180.
-            start_lon = lon - 360.
-
-        splash_windows = self.setup_splash()
-
-        geom = self.display.root.get_geometry()
-        height = float(geom.height) / float(geom.width)
-
-        self.display.root["IG_WORLD_LAT"] = start_lat
-        self.display.root["IG_WORLD_LON"] = start_lon
-        self.display.root["IG_WORLD_ZOOM"] = .1
-
-        self.display.root["IG_INITIAL_ANIMATE"] = {
-            "steps": [
-                {"window": self.display.root, "atom": "IG_VIEW_DESKTOP_VIEW", "dst": [-50.0, height * -50.0, 100.0, height * 100.0]},
-                {"window": self.display.root, "atom": "IG_VIEWS", "dst": ["IG_VIEW_ROOT", "IG_VIEW_DESKTOP", "IG_VIEW_SPLASH_BACKGROUND", "IG_VIEW_SPLASH"]},
-                {"tasks": [
-                    {"window": self.display.root, "atom": "IG_WORLD_LAT", "timeframe": 3.0, "dst": lat, "easing": "OutCubic"},
-                    {"window": self.display.root, "atom": "IG_WORLD_LON", "timeframe": 3.0, "dst": lon, "easing": "OutCubic"},
-                    {"window": self.display.root, "atom": "IG_WORLD_ZOOM", "timeframe": 3.0, "dst": 40.0, "easing": "InCubic"}
-                ]},
-                {"tasks": [
-                    {"window": self.display.root, "atom": "IG_WORLD_ALPHA", "timeframe": 2.0, "dst": 0.0},
-                    {"window": self.display.root, "atom": "IG_WORLD_ZOOM", "timeframe": 2.0, "dst": 400.0},
-                    {"window": self.display.root, "atom": "IG_VIEW_DESKTOP_VIEW", "timeframe": 2.0, "dst": [0.0, 0.0, 1.0, height]}
-                ]},
-                {"window": self.display.root, "atom": "IG_VIEWS", "dst": ["IG_VIEW_ROOT", "IG_VIEW_DESKTOP", "IG_VIEW_OVERLAY", "IG_VIEW_MENU"]},
-                {"window": self.display.root, "atom": "IG_THEME", "dst": 1.0}
-            ]
-        }
-        anim = self.display.root["IG_ANIMATE"]
-        anim.send(anim, "IG_ANIMATE", self.display.root, "IG_INITIAL", 0.0, event_mask=Xlib.X.PropertyChangeMask)
-
-        @self.display.root.on()
-        def PropertyNotify(win, event):
-            if self.display.get_atom_name(event.atom) == "IG_THEME":
-                for w in splash_windows:
-                    w.destroy()
-                sys.exit(0)
-
-    def setup_splash_test(self):
-        lat, lon = self.latlon
-        splash_windows = self.setup_splash()
-        self.display.root["IG_VIEWS"] = ["IG_VIEW_SPLASH_BACKGROUND", "IG_VIEW_SPLASH"]
-        self.display.root["IG_WORLD_LAT"] = lat
-        self.display.root["IG_WORLD_LON"] = lon
-        self.display.root["IG_WORLD_ZOOM"] = 1.
-