bump version to v0.0.11

and some smaller cosmetic changes

README.md

@@ -5,10 +5,8 @@
  / ___ \| |_) | |___ ___) | |_| |
 /_/   \_\____/ \____|____/|____/
 ```
-v0.0.10
+v0.0.11
 
-Convenience tool to work with 3D typography in Blender and Cinema4D.
+Convenience addon to work with 3D typography in Blender and Cinema4D.
-
-Install as you would normally install an addon.
 
 Instructions for development in [CONTRIBUTING,md](./CONTRIBUTING.md).

__init__.py

@@ -16,7 +16,7 @@ from .common import Font, utils
 bl_info = {
     "name": "ABC3D",
     "author": "Jakob Schlötter, Studio Pointer*",
-    "version": (0, 0, 10),
+    "version": (0, 0, 11),
     "blender": (4, 1, 0),
     "location": "VIEW3D",
     "description": "Convenience addon for 3D fonts",
@@ -35,6 +35,7 @@ if "Font" in locals():
     importlib.reload(bimport)
     importlib.reload(addon_updater_ops)
 
+
 def getPreferences(context):
     preferences = context.preferences
     return preferences.addons[__name__].preferences
@@ -158,6 +159,7 @@ class ABC3D_glyph_properties(bpy.types.PropertyGroup):
         update=update_callback,
     )
 
+
 class ABC3D_text_properties(bpy.types.PropertyGroup):
     def font_items_callback(self, context):
         items = []
@@ -165,21 +167,6 @@ class ABC3D_text_properties(bpy.types.PropertyGroup):
             items.append((f"{f[0]} {f[1]}", f"{f[0]} {f[1]}", ""))
         return items
 
-    def font_default_callback(self, context):
-        d = context.scene.abc3d_data
-        if len(d.available_fonts) > 0:
-            if len(d.available_fonts) > d.active_text_index:
-                f = d.available_fonts[d.active_text_index]
-                return 0  # f"{f.font_name} {f.face_name}"
-            else:
-                f = d.available_fonts[0]
-                return 0  # f"{f.font_name} {f.face_name}"
-
-        if not isinstance(self.font_name, None) and not isinstance(self.face_name, None):
-            return 0  # f"{self.font_name} {self.face_name}"
-        else:
-            return 0  # ""
-
     def glyphs_update_callback(self, context):
         butils.prepare_text(self.font_name, self.face_name, self.text)
         butils.set_text_on_curve(self, can_regenerate=True)
@@ -282,20 +269,28 @@ class ABC3D_data(bpy.types.PropertyGroup):
     )
 
     def active_text_index_update(self, context):
+        lock_depsgraph_updates()
         if self.active_text_index != -1:
-            text_properties = butils.get_text_properties(self.active_text_index, context.scene)
+            text_properties = butils.get_text_properties_by_index(
+                self.active_text_index, context.scene
+            )
             if text_properties is not None:
                 o = text_properties.text_object
                 # active_text_index changed. so let's update the selection
                 # check if it is already selected
                 # or perhaps one of the glyphs
-                if (o is not None
+                if os is not None and not butils.is_or_has_parent(
-                    and not o.select_get()
+                    context.active_object, o
-                    and not len([c for c in o.children if c.select_get()]) > 0
                 ):
+                    # if (
+                    #     o is not None
+                    #     and not o.select_get()
+                    #     and not len([c for c in o.children if c.select_get()]) > 0
+                    # ):
                     bpy.ops.object.select_all(action="DESELECT")
                     o.select_set(True)
                     context.view_layer.objects.active = o
+        unlock_depsgraph_updates()
         # else:
         # print("already selected")
 
@@ -346,7 +341,7 @@ class ABC3D_UL_texts(bpy.types.UIList):
 
 
 class ABC3D_PT_Panel(bpy.types.Panel):
-    bl_label = f"{__name__} panel"
+    bl_label = f"{utils.prefix()} Panel"
     bl_category = "ABC3D"
     bl_space_type = "VIEW_3D"
     bl_region_type = "UI"
@@ -354,6 +349,9 @@ class ABC3D_PT_Panel(bpy.types.Panel):
     def draw(self, context):
         layout = self.layout
 
+        row = layout.row()
+        row.label(text=f"{utils.prefix()} v{utils.get_version_string()}")
+
         icon = "NONE"
         if len(context.scene.abc3d_data.available_fonts) == 0:
             icon = "ERROR"
@@ -393,7 +391,10 @@ class ABC3D_PT_FontList(bpy.types.Panel):
             abc3d_data,
             "active_font_index",
         )
-        if abc3d_data.active_font_index >= 0:
+        if (
+            abc3d_data.active_font_index >= 0
+            and len(abc3d_data.available_fonts) > abc3d_data.active_font_index
+        ):
             available_font = abc3d_data.available_fonts[abc3d_data.active_font_index]
             font_name = available_font.font_name
             face_name = available_font.face_name
@@ -442,6 +443,13 @@ class ABC3D_PT_FontList(bpy.types.Panel):
                 )
                 oper_lf.font_name = font_name
                 oper_lf.face_name = face_name
+        box = layout.box()
+        row = box.row()
+        row.label(text="File and Memory optimization")
+        row = box.row()
+        row.operator(f"{__name__}.refresh_fonts", text="Refresh font list from disk")
+        row = box.row()
+        row.operator(f"{__name__}.unload_unused_glyphs", text="Unload unused glyphs")
 
 
 class ABC3D_PT_TextPlacement(bpy.types.Panel):
@@ -455,10 +463,7 @@ class ABC3D_PT_TextPlacement(bpy.types.Panel):
 
     @classmethod
     def poll(self, context):
-        if (
+        if context.active_object is not None and context.active_object.type == "CURVE":
-            context.active_object is not None
-            and context.active_object.type == "CURVE"
-        ):
             self.can_place = True
         else:
             self.can_place = False
@@ -487,99 +492,6 @@ class ABC3D_PT_TextManagement(bpy.types.Panel):
     bl_region_type = "UI"
     bl_options = {"DEFAULT_CLOSED"}
 
-    # TODO: perhaps this should be done in a periodic timer
-    @classmethod
-    def poll(self, context):
-        scene = context.scene
-        abc3d_data = scene.abc3d_data
-        # TODO: update available_texts
-
-        def update():
-            if bpy.context.screen.is_animation_playing:
-                return
-            active_text_index = -1
-            remove_list = []
-            for i, t in enumerate(abc3d_data.available_texts):
-                if type(t.text_object) == type(None):
-                    remove_list.append(i)
-                    continue
-                remove_me = True
-                for c in t.text_object.children:
-                    if (
-                        len(c.users_collection) > 0
-                        and not isinstance(c.get(f"{utils.prefix()}_text_id"), None)
-                        and c.get(f"{utils.prefix()}_text_id") == t.text_id
-                    ):
-                        remove_me = False
-                        # not sure how to solve this reliably atm,
-                        # we need to reassign the glyph, but also get the proper properties from glyph_properties
-                        # these might be there in t.glyphs, but linked to removed objects
-                        # or they might be lost
-                        if type(
-                            next(
-                                (
-                                    g
-                                    for g in t.glyphs
-                                    if type(g.glyph_object) == type(None)
-                                ),
-                                None,
-                            )
-                        ) == type(None):
-                            g = next(
-                                (
-                                    g
-                                    for g in t.glyphs
-                                    if type(g.glyph_object) == type(None)
-                                ),
-                                None,
-                            )
-                        # for g in t.glyphs:
-                        # if type(g) == type(None):
-                        # print("IS NONE")
-                        # if type(g.glyph_object) == type(None):
-                        # print("go IS NONE")
-                        # else:
-                        # if g.glyph_object == c:
-                        # # print(g.glyph_object.name)
-                        # pass
-
-                if remove_me:
-                    remove_list.append(i)
-
-            for i in remove_list:
-                if abc3d_data.available_texts[i].text_object is not None:
-                    mom = abc3d_data.available_texts[i].text_object
-
-                    def delif(o, p):
-                        if p in o:
-                            del o[p]
-
-                    delif(mom, f"{utils.prefix()}_text_id")
-                    delif(mom, f"{utils.prefix()}_font_name")
-                    delif(mom, f"{utils.prefix()}_face_name")
-                    delif(mom, f"{utils.prefix()}_font_size")
-                    delif(mom, f"{utils.prefix()}_letter_spacing")
-                    delif(mom, f"{utils.prefix()}_orientation")
-                    delif(mom, f"{utils.prefix()}_translation")
-                    delif(mom, f"{utils.prefix()}_offset")
-                abc3d_data.available_texts.remove(i)
-
-            for i, t in enumerate(abc3d_data.available_texts):
-                if context.active_object == t.text_object:
-                    active_text_index = i
-                if (
-                    hasattr(context.active_object, "parent")
-                    and context.active_object.parent == t.text_object
-                ):
-                    active_text_index = i
-
-            if active_text_index != abc3d_data.active_text_index:
-                abc3d_data.active_text_index = active_text_index
-
-        # butils.run_in_main_thread(update)
-
-        return True
-
     def draw(self, context):
         layout = self.layout
         wm = context.window_manager
@@ -649,6 +561,7 @@ class ABC3D_PG_FontCreation(bpy.types.PropertyGroup):
         update=naming_glyph_id_update_callback,
     )
 
+
 class ABC3D_OT_NamingHelper(bpy.types.Operator):
     bl_label = "Font Creation Naming Helper Apply To Active Object"
     bl_idname = f"{__name__}.apply_naming_helper"
@@ -686,7 +599,10 @@ class ABC3D_PT_NamingHelper(bpy.types.Panel):
         box.row().prop(abc3d_font_creation, "face_name")
         box.label(text="Glyph Output Name")
         box.row().prop(abc3d_font_creation, "naming_glyph_name")
-        box.row().operator(f"{__name__}.apply_naming_helper", text="Apply name to active object")
+        box.row().operator(
+            f"{__name__}.apply_naming_helper", text="Apply name to active object"
+        )
+
 
 class ABC3D_PT_FontCreation(bpy.types.Panel):
     bl_label = "Font Creation"
@@ -725,7 +641,10 @@ class ABC3D_PT_FontCreation(bpy.types.Panel):
             f"{__name__}.temporaryhelper", text="Debug Function Do Not Use"
         )
         box.label(text="origin points")
-        box.row().operator(f"{__name__}.align_origins_to_active_object", text="Align origins to Active Object")
+        box.row().operator(
+            f"{__name__}.align_origins_to_active_object",
+            text="Align origins to Active Object",
+        )
         # box.row().operator(f"{__name__}.align_origins_to_metrics", text="Align origins to Metrics (left)")
         # box.row().operator(f"{__name__}.fix_objects_metrics_origins", text="Fix objects metrics origins")
 
@@ -749,54 +668,36 @@ class ABC3D_PT_TextPropertiesPanel(bpy.types.Panel):
                 return bpy.context.scene.abc3d_data.available_texts[text_index]
             else:
                 for t in bpy.context.scene.abc3d_data.available_texts:
-                    if butils.is_or_has_parent(bpy.context.active_object, t.text_object, max_depth=4):
+                    if butils.is_or_has_parent(
+                        bpy.context.active_object, t.text_object, max_depth=4
+                    ):
                         return t
         return None
 
     def get_active_glyph_properties(self):
         a_o = bpy.context.active_object
         if a_o is not None:
-            if (f"{utils.prefix()}_text_id" in a_o
+            if (
-                    and f"{utils.prefix()}_glyph_index" in a_o):
+                f"{utils.prefix()}_text_id" in a_o
+                and f"{utils.prefix()}_glyph_index" in a_o
+            ):
                 text_index = a_o[f"{utils.prefix()}_text_id"]
                 glyph_index = a_o[f"{utils.prefix()}_glyph_index"]
-                return bpy.context.scene.abc3d_data.available_texts[text_index].glyphs[glyph_index]
+                return bpy.context.scene.abc3d_data.available_texts[text_index].glyphs[
+                    glyph_index
+                ]
             else:
                 for t in bpy.context.scene.abc3d_data.available_texts:
-                    if butils.is_or_has_parent(a_o, t.text_object, if_is_parent=False, max_depth=4):
+                    if butils.is_or_has_parent(
+                        a_o, t.text_object, if_is_parent=False, max_depth=4
+                    ):
                         for g in t.glyphs:
-                            if butils.is_or_has_parent(a_o, g.glyph_object, max_depth=4):
+                            if butils.is_or_has_parent(
+                                a_o, g.glyph_object, max_depth=4
+                            ):
                                 return g
         return None
 
-
-    # def font_items_callback(self, context):
-    # items = []
-    # fonts = Font.get_loaded_fonts_and_faces()
-    # for f in fonts:
-    # items.append((f"{f[0]} {f[1]}", f"{f[0]} {f[1]}", ""))
-    # return items
-
-    # def font_default_callback(self, context):
-    # t = self.get_active_text_properties(self)
-    # if type(t) != type(None):
-    # return f"{t.font_name} {t.face_name}"
-    # else:
-    # return None
-
-    # def font_update_callback(self, context):
-    # font_name, face_name = self.font.split(" ")
-    # t = self.get_active_text_properties(self)
-    # t.font_name = font_name
-    # t.face_name = face_name
-    # butils.set_text_on_curve(t)
-
-    # font: bpy.props.EnumProperty(
-    # items=font_items_callback,
-    # default=font_default_callback,
-    # update=font_update_callback,
-    # )
-
     @classmethod
     def poll(self, context):
         try:
@@ -840,6 +741,32 @@ class ABC3D_PT_TextPropertiesPanel(bpy.types.Panel):
         box.row().prop(glyph_props, "letter_spacing")
 
 
+class ABC3D_OT_RefreshAvailableFonts(bpy.types.Operator):
+    """Refreshes available font list from disk.
+    This also removes all fonts which are not saved in the asset directory.
+    Can be useful when creating fonts or manually installing fonts."""
+
+    bl_idname = f"{__name__}.refresh_fonts"
+    bl_label = "Refresh Available Fonts"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        refresh_fonts()
+        return {"FINISHED"}
+
+
+class ABC3D_OT_UnloadUnusedGlyphs(bpy.types.Operator):
+    """Unload all glyphs which are not actively used in this project from memory.
+    They will still be normally loaded when you use them again."""
+
+    bl_idname = f"{__name__}.unload_unused_glyphs"
+    bl_label = "Unload Unused Glyphs"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        butils.unload_unused_glyphs()
+        return {"FINISHED"}
+
 
 class ABC3D_OT_InstallFont(bpy.types.Operator):
     """Install or load Fontfile from path above.
@@ -999,7 +926,6 @@ class ABC3D_OT_LoadInstalledFonts(bpy.types.Operator):
         return context.window_manager.invoke_props_dialog(self)
 
     def execute(self, context):
-        print("EXECUTE LOAD INSTALLED FONTS")
         scene = bpy.context.scene
 
         if self.load_into_memory:
@@ -1026,7 +952,14 @@ class ABC3D_OT_LoadFont(bpy.types.Operator):
     def execute(self, context):
         face: Font.FontFace = Font.get_font_face(self.font_name, self.face_name)
         if face is None:
-            butils.ShowMessageBox(f"{utils.prefix()} Load Font", icon="ERROR", message=["Could not load font, sorry!", f"{self.font_name=} {self.face_name=}"])
+            butils.ShowMessageBox(
+                f"{utils.prefix()} Load Font",
+                icon="ERROR",
+                message=[
+                    "Could not load font, sorry!",
+                    f"{self.font_name=} {self.face_name=}",
+                ],
+            )
             return {"CANCELLED"}
         filepaths = face.filepaths
         for f in filepaths:
@@ -1090,6 +1023,7 @@ class ABC3D_OT_AlignMetrics(bpy.types.Operator):
         butils.align_metrics_of_objects(objects)
         return {"FINISHED"}
 
+
 class ABC3D_OT_AlignOriginsToActiveObject(bpy.types.Operator):
     """Align origins of selected objects to origin of active object on one axis."""
 
@@ -1097,14 +1031,15 @@ class ABC3D_OT_AlignOriginsToActiveObject(bpy.types.Operator):
     bl_label = "Align origins to Active Object"
     bl_options = {"REGISTER", "UNDO"}
 
-    enum_axis = (('0','X',''),('1','Y',''),('2','Z',''))
+    enum_axis = (("0", "X", ""), ("1", "Y", ""), ("2", "Z", ""))
-    axis: bpy.props.EnumProperty(items = enum_axis, default='2')
+    axis: bpy.props.EnumProperty(items=enum_axis, default="2")
 
     def execute(self, context):
         objects = bpy.context.selected_objects
         butils.align_origins_to_active_object(objects, int(self.axis))
         return {"FINISHED"}
 
+
 # class ABC3D_OT_AlignOriginsToMetrics(bpy.types.Operator):
 # """Align origins of selected objects to their metrics left border.
 
@@ -1157,6 +1092,7 @@ class ABC3D_OT_AlignOriginsToActiveObject(bpy.types.Operator):
 # butils.fix_objects_metrics_origins(objects)
 # return {"FINISHED"}
 
+
 class ABC3D_OT_TemporaryHelper(bpy.types.Operator):
     """Temporary Helper ABC3D\nThis could do anything.\nIt's just there to make random functions available for testing."""
 
@@ -1210,6 +1146,7 @@ class ABC3D_OT_RemoveText(bpy.types.Operator):
 
     def execute(self, context):
         abc3d_data = context.scene.abc3d_data
+        lock_depsgraph_updates()
         if abc3d_data.active_text_index < 0:
             butils.ShowMessageBox(
                 title="No text selected",
@@ -1223,6 +1160,7 @@ class ABC3D_OT_RemoveText(bpy.types.Operator):
             mom = abc3d_data.available_texts[i].text_object
 
             if self.remove_custom_properties:
+
                 def delif(o, p):
                     if p in o:
                         del o[p]
@@ -1244,6 +1182,7 @@ class ABC3D_OT_RemoveText(bpy.types.Operator):
             butils.simply_delete_objects(remove_list)
 
         abc3d_data.available_texts.remove(i)
+        unlock_depsgraph_updates()
 
         return {"FINISHED"}
 
@@ -1327,10 +1266,7 @@ class ABC3D_OT_PlaceText(bpy.types.Operator):
 
             distribution_type = "DEFAULT"
 
-            text_id = 0
+            text_id = butils.find_free_text_id()
-            for i, tt in enumerate(abc3d_data.available_texts):
-                while text_id == tt.text_id:
-                    text_id = text_id + 1
             t = abc3d_data.available_texts.add()
             # If you wish to set a value and not fire an update, set the id property.
             # A property defined via bpy.props for example ob.prop is stored as ob["prop"] once set to non default.
@@ -1372,7 +1308,8 @@ class ABC3D_OT_PlaceText(bpy.types.Operator):
 class ABC3D_OT_ToggleABC3DCollection(bpy.types.Operator):
     """Toggle ABC3D Collection.
 
-    This will show the Fonts and Glyphs currently loaded by ABC3D. Useful for font creation, debugging and inspection."""
+    This will show the Fonts and Glyphs currently loaded by ABC3D. Useful for font creation, debugging and inspection.
+    """
 
     bl_idname = f"{__name__}.toggle_abc3d_collection"
     bl_label = "Toggle Collection visibility"
@@ -1463,7 +1400,9 @@ class ABC3D_OT_SaveFontToFile(bpy.types.Operator):
                 row.label(text="Please select another directory")
                 row = layout.row()
                 row.alert = True
-            elif not utils.can_create_path(export_dir): # does not exist and cannot be created
+            elif not utils.can_create_path(
+                export_dir
+            ):  # does not exist and cannot be created
                 self.can_execute = False
                 row.alert = True
                 row.label(text="Directory does not exist and cannot be created")
@@ -1487,7 +1426,9 @@ class ABC3D_OT_SaveFontToFile(bpy.types.Operator):
 
             row.prop(abc3d_data, "export_dir")
         else:
-            print(f"{utils.prefix()}::save_font_to_file ERROR {face=} {font_name=} {face_name=}")
+            print(
+                f"{utils.prefix()}::save_font_to_file ERROR {face=} {font_name=} {face_name=}"
+            )
             print(f"{utils.prefix()}                          {Font.fonts=}")
 
     def execute(self, context):
@@ -1500,10 +1441,10 @@ class ABC3D_OT_SaveFontToFile(bpy.types.Operator):
                 "ERROR",
                 [
                     f"export directory '{abc3d_data.export_dir}' does not exist or is not writable",
-                    "try setting another path"
+                    "try setting another path",
-                ]
+                ],
             )
-            return {'CANCELLED'}
+            return {"CANCELLED"}
 
         if not os.path.exists(butils.bpy_to_abspath(abc3d_data.export_dir)):
             path = butils.bpy_to_abspath(abc3d_data.export_dir)
@@ -1515,10 +1456,10 @@ class ABC3D_OT_SaveFontToFile(bpy.types.Operator):
                     "ERROR",
                     [
                         f"export directory '{abc3d_data.export_dir}' does not exist and cannot be created",
-                        "try setting another path"
+                        "try setting another path",
-                    ]
+                    ],
                 )
-                return {'CANCELLED'}
+                return {"CANCELLED"}
 
         fontcollection = bpy.data.collections.get("ABC3D")
 
@@ -1598,9 +1539,11 @@ class ABC3D_OT_SaveFontToFile(bpy.types.Operator):
                 use_selection=True,
                 use_active_scene=True,
             )
+
             def delete_scene():
                 bpy.ops.scene.delete()
                 return None
+
             bpy.app.timers.register(lambda: delete_scene(), first_interval=1)
 
             # bpy.ops.scene.delete()
@@ -1669,7 +1612,9 @@ class ABC3D_OT_CreateFontFromObjects(bpy.types.Operator):
             row.prop(self, "autodetect_names")
             first_object_name = context.selected_objects[-1].name
             if self.autodetect_names:
-                self.font_name, self.face_name = self.do_autodetect_names(first_object_name)
+                self.font_name, self.face_name = self.do_autodetect_names(
+                    first_object_name
+                )
             if self.autodetect_names:
                 scale_y = 0.5
                 row = layout.row()
@@ -1829,6 +1774,8 @@ classes = (
     ABC3D_PT_NamingHelper,
     ABC3D_PT_TextPropertiesPanel,
     ABC3D_OT_OpenAssetDirectory,
+    ABC3D_OT_RefreshAvailableFonts,
+    ABC3D_OT_UnloadUnusedGlyphs,
     ABC3D_OT_LoadInstalledFonts,
     ABC3D_OT_LoadFont,
     ABC3D_OT_AddDefaultMetrics,
@@ -1867,14 +1814,35 @@ def compare_text_object_with_object(t, o, strict=False):
     # if
     return True
 
+
 def link_text_object_with_new_text_properties(text_object, scene=None):
-    lock_depsgraph_updates(auto_unlock_s=-1)
+    lock_depsgraph_updates()
     butils.link_text_object_with_new_text_properties(text_object, scene)
     unlock_depsgraph_updates()
 
 
+def determine_active_text_index_from_selection():
+    if bpy.context.active_object is None:
+        return -1
+    for text_index, text_properties in enumerate(
+        bpy.context.scene.abc3d_data.available_texts
+    ):
+        if butils.is_text_object_legit(text_properties.text_object):
+            if butils.is_or_has_parent(
+                bpy.context.active_object, text_properties.text_object
+            ):
+                return text_index
+    return -1
+
+
+def update_active_text_index():
+    text_index = determine_active_text_index_from_selection()
+    if text_index != bpy.context.scene.abc3d_data.active_text_index:
+        bpy.context.scene.abc3d_data.active_text_index = text_index
+
+
 def detect_text():
-    lock_depsgraph_updates(auto_unlock_s=-1)
+    lock_depsgraph_updates()
     scene = bpy.context.scene
     abc3d_data = scene.abc3d_data
     required_keys = [
@@ -1896,10 +1864,7 @@ def detect_text():
         if o[butils.get_key("type")] == "textobject":
             current_text_id = int(o[butils.get_key("text_id")])
             text_properties = butils.get_text_properties(current_text_id)
-            if (
+            if text_properties is not None and text_properties.text_object == o:
-                text_properties is not None
-                and text_properties.text_object == o
-            ):
                 # all good
                 pass
             else:
@@ -1934,6 +1899,21 @@ def load_used_glyphs():
                 butils.load_font_from_filepath(fp, a.unloaded)
 
 
+def refresh_fonts():
+    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
+    if fontcollection is not None:
+        objs = [o for o in fontcollection.objects if o.parent == None]
+        butils.completely_delete_objects(objs)
+    butils.run_in_main_thread(Font.fonts.clear)
+    butils.run_in_main_thread(butils.clear_available_fonts)
+    butils.run_in_main_thread(butils.register_installed_fonts)
+    butils.run_in_main_thread(butils.update_available_fonts)
+    butils.run_in_main_thread(load_used_glyphs)
+    butils.run_in_main_thread(butils.update_types)
+    butils.run_in_main_thread(detect_text)
+    butils.run_in_main_thread(butils.unload_unused_glyphs)
+
+
 @persistent
 def load_handler(self, dummy):
     if not bpy.app.timers.is_registered(butils.execute_queued_functions):
@@ -1964,7 +1944,7 @@ def unlock_depsgraph_updates():
     depsgraph_updates_locked -= 1
 
 
-def lock_depsgraph_updates(auto_unlock_s=1):
+def lock_depsgraph_updates(auto_unlock_s=-1):
     global depsgraph_updates_locked
     depsgraph_updates_locked += 1
     if auto_unlock_s >= 0:
@@ -1972,15 +1952,19 @@ def lock_depsgraph_updates(auto_unlock_s=1):
             bpy.app.timers.unregister(unlock_depsgraph_updates)
         bpy.app.timers.register(unlock_depsgraph_updates, first_interval=auto_unlock_s)
 
+
 def are_depsgraph_updates_locked():
     global depsgraph_updates_locked
     return depsgraph_updates_locked > 0
 
+
 import time
 
+
 @persistent
 def on_depsgraph_update(scene, depsgraph):
     if not bpy.context.mode.startswith("EDIT") and not are_depsgraph_updates_locked():
+        lock_depsgraph_updates(auto_unlock_s=-1)
         for u in depsgraph.updates:
             if (
                 butils.get_key("text_id") in u.id.keys()
@@ -1994,12 +1978,18 @@ def on_depsgraph_update(scene, depsgraph):
                     if text_properties.text_object == u.id.original:
                         # nothing to do
                         pass
-                    else:
+                    elif butils.is_text_object_legit(u.id.original):
                         # must be duplicate
                         link_text_object_with_new_text_properties(u.id.original, scene)
-                else:
+                elif (
-                    # must be new thing
+                    butils.is_text_object_legit(u.id.original)
+                    and len(u.id.original.users_collection) > 0
+                ):
+                    # must be a new thing, maybe manually created or so
                     link_text_object_with_new_text_properties(u.id.original, scene)
+                butils.clean_text_properties()
+        update_active_text_index()
+        unlock_depsgraph_updates()
 
 
 def register():
@@ -2010,7 +2000,9 @@ def register():
         addon_updater_ops.make_annotations(cls)  # Avoid blender 2.8 warnings.
         bpy.utils.register_class(cls)
     bpy.types.Scene.abc3d_data = bpy.props.PointerProperty(type=ABC3D_data)
-    bpy.types.Scene.abc3d_font_creation = bpy.props.PointerProperty(type=ABC3D_PG_FontCreation)
+    bpy.types.Scene.abc3d_font_creation = bpy.props.PointerProperty(
+        type=ABC3D_PG_FontCreation
+    )
     # bpy.types.Object.__del__ = lambda self: print(f"Bye {self.name}")
 
     # autostart if we load a blend file
@@ -2025,6 +2017,7 @@ def register():
     if on_depsgraph_update not in bpy.app.handlers.depsgraph_update_post:
         bpy.app.handlers.depsgraph_update_post.append(on_depsgraph_update)
 
+    butils.run_in_main_thread(Font.fonts.clear)
     butils.run_in_main_thread(butils.clear_available_fonts)
     butils.run_in_main_thread(butils.register_installed_fonts)
     butils.run_in_main_thread(butils.update_available_fonts)

butils.py

@@ -4,6 +4,7 @@ import queue
 import re
 
 import bpy
+import bpy_types
 import mathutils
 
 # import time # for debugging performance
@@ -45,12 +46,14 @@ def apply_all_transforms(obj):
     obj.matrix_basis.identity()
 
 
-def get_parent_collection_names(collection, parent_names):
+# broken
-    for parent_collection in bpy.data.collections:
+# def get_parent_collection_names(collection, parent_names):
-        if collection.name in parent_collection.children.keys():
+#     for parent_collection in bpy.data.collections:
-            parent_names.append(parent_collection.name)
+#         if collection.name in parent_collection.children.keys():
-            get_parent_collection_names(parent_collection, parent_names)
+#             parent_names.append(parent_collection.name)
-            return
+#             get_parent_collection_names(parent_collection, parent_names)
+#             return
+
 
 def get_key(key):
     return f"{utils.prefix()}_{key}"
@@ -157,7 +160,6 @@ def calc_tangent_on_bezier(bezier_point_1, bezier_point_2, t):
 # calc_point_on_bezier(a,b,0.5)
 
 
-
 def align_rotations_auto_pivot(
     mask, input_rotations, vectors, factors, local_main_axis
 ):
@@ -251,7 +253,7 @@ def calc_point_on_bezier_spline(
     # however, maybe let's have it not crash and do this
     if len(bezier_spline_obj.bezier_points) < 1:
         print(
-            "butils::calc_point_on_bezier_spline: whoops, no points. panicking. return 0,0,0"
+            f"{utils.prefix()}::butils::calc_point_on_bezier_spline: whoops, no points. panicking. return 0,0,0"
         )
         if output_tangent:
             return mathutils.Vector((0, 0, 0)), mathutils.Vector((1, 0, 0))
@@ -275,8 +277,9 @@ def calc_point_on_bezier_spline(
         # if the bezier points sit on each other we have same issue
         # but that is then to be fixed in the bezier
         if p.handle_left == p.co and len(bezier_spline_obj.bezier_points) > 1:
-            beziers, lengths, total_length = get_real_beziers_and_lengths(bezier_spline_obj,
+            beziers, lengths, total_length = get_real_beziers_and_lengths(
-                                                                          resolution_factor)
+                bezier_spline_obj, resolution_factor
+            )
             travel_point = calc_point_on_bezier(beziers[0][1], beziers[0][0], 0.001)
             travel = travel_point.normalized() * distance
 
@@ -288,8 +291,9 @@ def calc_point_on_bezier_spline(
         else:
             return location
 
-    beziers, lengths, total_length = get_real_beziers_and_lengths(bezier_spline_obj,
+    beziers, lengths, total_length = get_real_beziers_and_lengths(
-                                                                  resolution_factor)
+        bezier_spline_obj, resolution_factor
+    )
 
     iterated_distance = 0
     for i in range(0, len(beziers)):
@@ -368,6 +372,7 @@ def calc_point_on_bezier_curve(
     # and should not happen usually
     return bezier_curve_obj.matrix_world @ mathutils.Vector((distance, 0, 0))
 
+
 # def get_objects_by_name(name, startswith="", endswith=""):
 # return [obj for obj in bpy.context.scene.objects if obj.name.startswith(startswith) and if obj.name.endswith(endswith)]
 
@@ -397,13 +402,14 @@ def find_objects_by_custom_property(objects, property_name="", property_value=""
     ]
 
 
-def turn_collection_hierarchy_into_path(obj):
+# not verified
-    parent_collection = obj.users_collection[0]
+# def turn_collection_hierarchy_into_path(obj):
-    parent_names = []
+#     parent_collection = obj.users_collection[0]
-    parent_names.append(parent_collection.name)
+#     parent_names = []
-    get_parent_collection_names(parent_collection, parent_names)
+#     parent_names.append(parent_collection.name)
-    parent_names.reverse()
+#     get_parent_collection_names(parent_collection, parent_names)
-    return "\\".join(parent_names)
+#     parent_names.reverse()
+#     return "\\".join(parent_names)
 
 
 def find_font_object(fontcollection, font_name):
@@ -458,7 +464,9 @@ def move_in_fontcollection(obj, fontcollection, allow_duplicates=False):
         fontcollection.objects.link(glyphs_obj)
         glyphs_obj.parent = face_obj
     elif len(glyphs_objs) > 1:
-        print("found more glyphs objects than expected")
+        print(
+            f"{utils.prefix()}::move_in_fontcollection: found more glyphs objects than expected"
+        )
 
     # now it must exist
     glyphs_obj = find_objects_by_name(face_obj.children, startswith="glyphs")[0]
@@ -565,8 +573,12 @@ def load_font_from_filepath(filepath, glyphs="", font_name="", face_name=""):
         mff_glyphs = []
         face: Font.FontFace = Font.get_font_face(mff["font_name"], mff["face_name"])
         if face is None:
-            print(f"{utils.prefix()}::load_font_from_path({filepath=}, {glyphs=}, {font_name=}, {face_name=}) failed")
+            print(
-            print(f"modified font face {mff=} could not be accessed.")
+                f"{utils.prefix()}::load_font_from_path({filepath=}, {glyphs=}, {font_name=}, {face_name=}) failed"
+            )
+            print(
+                f"{utils.prefix()}::                   modified font face {mff=} could not be accessed."
+            )
             continue
         # iterate glyphs
         for g in face.glyphs:
@@ -592,6 +604,154 @@ def load_font_from_filepath(filepath, glyphs="", font_name="", face_name=""):
     # completely_delete_objects(remove_list)
 
 
+def is_glyph_used(glyph_alternates):
+    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
+    glyph = bpy.types.PointerProperty
+    for glyph in glyph_alternates:
+        for o in bpy.context.scene.objects:
+            # only check other glyphs
+            if is_glyph_object(o):
+                # then attempt to compare properties
+                if (
+                    get_key("font_name") in o
+                    and get_key("face_name") in o
+                    and get_key("glyph_id") in o
+                    and o[get_key("font_name")] == glyph["font_name"]
+                    and o[get_key("face_name")] == glyph["face_name"]
+                    and o[get_key("glyph_id")] == glyph["glyph"]
+                ):
+                    # following check is not necessary,
+                    # but we leave it in for backwards compatibility
+                    # properties in the fontcollection start with prefix
+                    # and so they should be caught by previous check
+                    if fontcollection.users == 0 or not (
+                        fontcollection in o.users_collection
+                        and len(o.users_collection) <= 1
+                    ):
+                        # it's in the scene and has the correct properties
+                        # it is used
+                        return True
+            # following check is possibly overkill
+            # but we also check for objects that use the data
+            # and are not glyph objects, in that case we don't pull the data
+            # from under their feet
+            if is_mesh(o) and o.data == glyph.data:
+                # in this case, yes we need to check if it is a glyph in the fontcollection
+                if fontcollection.users == 0 or not (
+                    fontcollection in o.users_collection
+                    and len(o.users_collection) <= 1
+                ):
+                    # bam!
+                    return True
+    # whoosh!
+    return False
+
+
+def clean_text_properties():
+    abc3d_data = bpy.context.scene.abc3d_data
+    remove_these = []
+    for i, text_properties in enumerate(abc3d_data.available_texts):
+        if len(text_properties.text_object.users_collection) <= 0:
+            remove_these.append(i)
+    remove_these.reverse()
+    for i in remove_these:
+        abc3d_data.available_texts.remove(i)
+
+
+def clean_fontcollection(fontcollection=None):
+    if fontcollection is None:
+        fontcollection = bpy.data.collections.get("ABC3D")
+    if fontcollection is None:
+        print(
+            f"{utils.prefix()}::clean_fontcollection: failed beacause fontcollection is none"
+        )
+        return False
+
+    collection_fonts = find_objects_by_custom_property(
+        fontcollection.all_objects, "is_font", True
+    )
+
+    delete_these_fonts = []
+    delete_these_font_faces = []
+    delete_these_glyph_moms = []
+    for font_and_face in Font.get_loaded_fonts_and_faces():
+        font_name = font_and_face[0]
+        face_name = font_and_face[1]
+
+        collection_font_list = find_objects_by_custom_property(
+            collection_fonts, "font_name", font_name
+        )
+        for collection_font in collection_font_list:
+            collection_font_face_list = find_objects_by_custom_property(
+                collection_font.children, "face_name", face_name
+            )
+            count_font_faces = 0
+            for collection_font_face in collection_font_face_list:
+                glyphs_mom_list = find_objects_by_name(
+                    collection_font_face.children, startswith="glyphs"
+                )
+                count_glyphs_moms = 0
+                for glyphs_mom in glyphs_mom_list:
+                    if len(glyphs_mom.children) == 0:
+                        delete_these_glyph_moms.append(glyphs_mom)
+                        count_glyphs_moms += 1
+                if len(collection_font_face.children) == count_glyphs_moms:
+                    delete_these_font_faces.append(collection_font_face)
+                    count_font_faces += 1
+            if len(collection_font.children) == count_font_faces:
+                delete_these_fonts.append(collection_font)
+
+    completely_delete_objects(delete_these_glyph_moms)
+    completely_delete_objects(delete_these_font_faces)
+    completely_delete_objects(delete_these_fonts)
+
+
+def unload_unused_glyph(font_name, face_name, glyph_id, do_clean_fontcollection=True):
+    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
+    glyph_variations = Font.get_glyphs(font_name, face_name, glyph_id)
+    if is_glyph_used(glyph_variations):
+        return False
+
+    delete_these = []
+    for glyph_pointer in glyph_variations:
+        for o in fontcollection.all_objects:
+            if (
+                is_glyph_object(o)
+                and o["font_name"] == font_name
+                and o["face_name"] == face_name
+                and o["glyph"] == glyph_id
+            ):
+                if len(o.users_collection) <= 1:
+                    delete_these.append(o)
+    completely_delete_objects(delete_these)
+
+    Font.unloaded_glyph(font_name, face_name, glyph_id)
+    if do_clean_fontcollection:
+        clean_fontcollection(fontcollection)
+    return True
+
+
+def unload_unused_glyphs(do_clean_fontcollection=True):
+    fontcollection: bpy_types.Collection = bpy.data.collections.get("ABC3D")
+    if fontcollection is not None:
+        for font_and_face in Font.get_loaded_fonts_and_faces():
+            font_name = font_and_face[0]
+            face_name = font_and_face[1]
+            face: Font.FontFace | None = Font.get_font_face(font_name, face_name)
+            if face is None:
+                print(
+                    f"{utils.prefix()}::unload_unused_glyphs: face is None {font_name=} {face_name=}"
+                )
+                continue
+            unloaded_these = []
+            for glyph_id in face.loaded_glyphs.copy():
+                unload_unused_glyph(
+                    font_name, face_name, glyph_id, do_clean_fontcollection=False
+                )
+    if do_clean_fontcollection:
+        clean_fontcollection(fontcollection)
+
+
 def update_available_fonts():
     abc3d_data = bpy.context.scene.abc3d_data
 
@@ -606,7 +766,9 @@ def update_available_fonts():
             f = abc3d_data.available_fonts.add()
             f.font_name = font_name
             f.face_name = face_name
-            print(f"{utils.prefix()}::update_available_fonts: {__name__} added {font_name} {face_name}")
+            print(
+                f"{utils.prefix()}::update_available_fonts: {__name__} added {font_name} {face_name}"
+            )
 
 
 # def update_available_texts():
@@ -724,6 +886,8 @@ def completely_delete_objects(objs, recursive=True):
             except ReferenceError:
                 # not important
                 pass
+            except RuntimeError:
+                pass
 
 
 def is_mesh(o):
@@ -753,7 +917,7 @@ def is_glyph_object(o):
         return o[f"{utils.prefix()}_type"] == "glyph"
     try:
         return (
-            type(o.parent) is not type(None)
+            o.parent is not None
             and "glyphs" in o.parent.name
             and is_mesh(o)
             and not is_metrics_object(o)
@@ -792,6 +956,7 @@ def get_glyph_advance(glyph_obj):
             return abs(c.bound_box[4][0] - c.bound_box[0][0])
     return abs(glyph_obj.bound_box[4][0] - glyph_obj.bound_box[0][0])
 
+
 def get_glyph_prepost_advances(glyph_obj):
     for c in glyph_obj.children:
         if is_metrics_object(c):
@@ -807,14 +972,16 @@ def get_glyph_height(glyph_obj):
 
 
 def prepare_text(font_name, face_name, text, allow_replacement=True):
-    availability = Font.test_glyphs_availability(
+    availability = Font.test_glyphs_availability(font_name, face_name, text)
-        font_name, face_name, text
-    )
     if isinstance(availability, int):
         if availability == Font.MISSING_FONT:
-            print(f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FONT")
+            print(
+                f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FONT"
+            )
         if availability is Font.MISSING_FACE:
-            print(f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FACE")
+            print(
+                f"{utils.prefix()}::prepare_text({font_name=}, {face_name=}, {text=}) failed with MISSING_FACE"
+            )
         return False
     loadable = availability.unloaded
     # possibly replace upper and lower case letters with each other
@@ -832,9 +999,16 @@ def prepare_text(font_name, face_name, text, allow_replacement=True):
             load_font_from_filepath(filepath, loadable, font_name, face_name)
     return True
 
+
 def predict_actual_text(text_properties):
-    availability = Font.test_availability(text_properties.font_name, text_properties.face_name, text_properties.text)
+    availability = Font.test_availability(
-    AVAILABILITY = Font.test_availability(text_properties.font_name, text_properties.face_name, text_properties.text.swapcase())
+        text_properties.font_name, text_properties.face_name, text_properties.text
+    )
+    AVAILABILITY = Font.test_availability(
+        text_properties.font_name,
+        text_properties.face_name,
+        text_properties.text.swapcase(),
+    )
     t_text = text_properties.text
     for c in availability.missing:
         t_text = t_text.replace(c, "")
@@ -842,6 +1016,7 @@ def predict_actual_text(text_properties):
         t_text = t_text.replace(c, "")
     return t_text
 
+
 def is_bezier(curve):
     if curve.type != "CURVE":
         return False
@@ -906,6 +1081,7 @@ COMPARE_TEXT_OBJECT_SAME = 0
 COMPARE_TEXT_OBJECT_DIFFER = 1
 COMPARE_TEXT_OBJECT_REGENERATE = 2
 
+
 def find_free_text_id():
     scene = bpy.context.scene
     abc3d_data = scene.abc3d_data
@@ -922,21 +1098,27 @@ def find_free_text_id():
             found_free = True
     return text_id
 
+
 def compare_text_properties_to_text_object(text_properties, o):
     for key in text_object_keys:
         if key in ignore_keys_in_text_object_comparison:
             continue
         object_key = get_key(key)
-        text_property = text_properties[key] if key in text_properties else getattr(text_properties, key)
+        text_property = (
+            text_properties[key]
+            if key in text_properties
+            else getattr(text_properties, key)
+        )
         text_object_property = o[object_key] if object_key in o else False
         if text_property != text_object_property:
             if key in keys_trigger_regeneration:
                 return COMPARE_TEXT_OBJECT_REGENERATE
             elif key in ["translation", "orientation"]:
                 if (
-                        text_property[0] != text_object_property[0] or
+                    text_property[0] != text_object_property[0]
-                        text_property[1] != text_object_property[1] or
+                    or text_property[1] != text_object_property[1]
-                        text_property[2] != text_object_property[2]):
+                    or text_property[2] != text_object_property[2]
+                ):
                     return COMPARE_TEXT_OBJECT_DIFFER
                 # else same
             else:
@@ -950,16 +1132,17 @@ def transfer_text_properties_to_text_object(text_properties, o):
         if key in ignore_keys_in_text_object_comparison:
             continue
         object_key = get_key(key)
-        text_property = text_properties[key] if key in text_properties else getattr(text_properties, key)
+        text_property = (
+            text_properties[key]
+            if key in text_properties
+            else getattr(text_properties, key)
+        )
         o[object_key] = text_property
     o[get_key("type")] = "textobject"
 
 
 def get_glyph(glyph_id, font_name, face_name, notify_on_replacement=False):
-    glyph_tmp = Font.get_glyph(font_name,
+    glyph_tmp = Font.get_glyph(font_name, face_name, glyph_id, -1)
-                               face_name,
-                               glyph_id,
-                               -1)
     if glyph_tmp is None:
         space_width = Font.is_space(glyph_id)
         if space_width:
@@ -973,7 +1156,7 @@ def get_glyph(glyph_id, font_name, face_name, notify_on_replacement=False):
                 text_properties.font_name,
                 text_properties.face_name,
                 possible_replacement,
-                -1
+                -1,
             )
             if glyph_tmp is not None:
                 message = message + f" (replaced with '{possible_replacement}')"
@@ -991,6 +1174,7 @@ def get_glyph(glyph_id, font_name, face_name, notify_on_replacement=False):
 
     return glyph_tmp.original
 
+
 def get_text_properties(text_id, scene=None):
     if scene is None:
         scene = bpy.context.scene
@@ -1000,7 +1184,23 @@ def get_text_properties(text_id, scene = None):
             return t
     return None
 
-def duplicate(obj, data=True, actions=True, add_to_collection=True, collection=None, recursive=True):
+def get_text_properties_by_index(text_index, scene=None):
+    if scene is None:
+        scene = bpy.context.scene
+    abc3d_data = scene.abc3d_data
+    if text_index >= len(abc3d_data.available_texts):
+        return None
+    return abc3d_data.available_texts[text_index]
+
+
+def duplicate(
+    obj,
+    data=True,
+    actions=True,
+    add_to_collection=True,
+    collection=None,
+    recursive=True,
+):
     obj_copy = obj.copy()
     if add_to_collection:
         if collection:
@@ -1019,8 +1219,13 @@ def duplicate(obj, data=True, actions=True, add_to_collection=True, collection=N
             # child_copy.matrix_parent_inverse = obj_copy.matrix_world.inverted()
     return obj_copy
 
-def transfer_text_object_to_text_properties(text_object, text_properties, id_from_text_properties=True):
+
-    possible_brother_text_id = text_object[get_key("text_id")] if get_key("text_id") in text_object else ""
+def transfer_text_object_to_text_properties(
+    text_object, text_properties, id_from_text_properties=True
+):
+    possible_brother_text_id = (
+        text_object[get_key("text_id")] if get_key("text_id") in text_object else ""
+    )
     for key in text_object_keys:
         if key in ignore_keys_in_text_object_comparison:
             continue
@@ -1028,12 +1233,17 @@ def transfer_text_object_to_text_properties(text_object, text_properties, id_fro
         if id_from_text_properties and key == "text_id":
             text_object[object_key] = text_properties["text_id"]
         else:
-            text_object_property = text_object[object_key] if object_key in text_object else False
+            text_object_property = (
+                text_object[object_key] if object_key in text_object else False
+            )
             if text_object_property is not False:
                 text_properties[key] = text_object_property
 
     if len(text_object.children) == 0:
-        if possible_brother_text_id != text_properties["text_id"] and possible_brother_text_id != "":
+        if (
+            possible_brother_text_id != text_properties["text_id"]
+            and possible_brother_text_id != ""
+        ):
             possible_brother_properties = get_text_properties(possible_brother_text_id)
             possible_brother_object = possible_brother_properties.text_object
             if possible_brother_object is not None:
@@ -1047,11 +1257,7 @@ def transfer_text_object_to_text_properties(text_object, text_properties, id_fro
 
     found_reconstructable_glyphs = False
     glyph_objects_with_indices = []
-    required_keys = [
+    required_keys = ["glyph_index", "glyph_id", "type"]
-            "glyph_index",
-            "glyph_id",
-            "type"
-            ]
     for glyph_object in text_object.children:
         if is_glyph_object(glyph_object):
             has_required_keys = True
@@ -1111,8 +1317,10 @@ def transfer_text_object_to_text_properties(text_object, text_properties, id_fro
         text_properties.glyphs.clear()
         unfortunate_children = text_object.children
         completely_delete_objects(unfortunate_children)
+
         def kill_children():
             completely_delete_objects(unfortunate_children)
+
         run_in_main_thread(kill_children)
 
     if "font_name" in text_properties and "face_name" in text_properties:
@@ -1128,9 +1336,11 @@ def link_text_object_with_new_text_properties(text_object, scene=None):
     text_properties = scene.abc3d_data.available_texts.add()
     text_properties["text_id"] = text_id
     # text_object[get_key("text_id")] = text_id
-    prepare_text(text_object[get_key("font_name")],
+    prepare_text(
+        text_object[get_key("font_name")],
         text_object[get_key("face_name")],
-                 text_object[get_key("text")])
+        text_object[get_key("text")],
+    )
     text_properties.text_object = text_object
     transfer_text_object_to_text_properties(text_object, text_properties)
 
@@ -1144,6 +1354,22 @@ def test_finding():
     o = bpy.context.active_object
     transfer_text_object_to_text_properties(o, t)
 
+
+def is_text_object_legit(text_object):
+    must_have_keys = [
+        get_key("font_name"),
+        get_key("face_name"),
+        get_key("text"),
+        get_key("type"),
+    ]
+    for key in must_have_keys:
+        if key not in text_object:
+            return False
+    if text_object[get_key("type")] != "textobject":
+        return False
+    return True
+
+
 # def detect_texts():
 # scene = bpy.context.scene
 # abc3d_data = scene.abc3d_data
@@ -1153,28 +1379,38 @@ def test_finding():
 # and o[get_key("t
 
 
-
 def link_text_object_and_text_properties(o, text_properties):
     text_id = text_properties.text_id
     o["text_id"] = text_id
     text_properties.textobject = o
 
+
 def get_glyph_object_property(text_properties, glyph_properties, key):
     if key in glyph_properties:
         return glyph_properties[key]
     if hasattr(glyph_properties, key):
         return getattr(glyph_properties, key)
-    return text_properties[key] if key in text_properties else getattr(text_properties, key)
+    return (
+        text_properties[key]
+        if key in text_properties
+        else getattr(text_properties, key)
+    )
 
-def transfer_properties_to_glyph_object(text_properties, glyph_properties, glyph_object):
+
+def transfer_properties_to_glyph_object(
+    text_properties, glyph_properties, glyph_object
+):
     for key in glyph_object_keys:
         if key in ignore_keys_in_glyph_object_transfer:
             continue
         object_key = get_key(key)
-        glyph_object[object_key] = get_glyph_object_property(text_properties, glyph_properties, key)
+        glyph_object[object_key] = get_glyph_object_property(
+            text_properties, glyph_properties, key
+        )
     glyph_object[get_key("type")] = "glyph"
     glyph_object[get_key("text_id")] = text_properties["text_id"]
 
+
 def transfer_glyph_object_to_glyph_properties(glyph_object, glyph_properties):
     for key in glyph_object_keys:
         if key in ignore_keys_in_glyph_object_transfer:
@@ -1182,6 +1418,7 @@ def transfer_glyph_object_to_glyph_properties(glyph_object, glyph_properties):
         glyph_properties[key] = glyph_object[get_key(key)]
     glyph_properties["text_id"] = glyph_object[get_key("text_id")]
 
+
 def would_regenerate(text_properties):
     predicted_text = predict_actual_text(text_properties)
     if text_properties.actual_text != predicted_text:
@@ -1218,9 +1455,10 @@ def update_matrices(obj):
         obj.matrix_world = obj.matrix_basis
 
         # else:
-        obj.matrix_world = obj.parent.matrix_world * \
+        obj.matrix_world = (
-                           obj.matrix_parent_inverse * \
+            obj.parent.matrix_world * obj.matrix_parent_inverse * obj.matrix_basis
-                           obj.matrix_basis
+        )
+
 
 def is_or_has_parent(o, parent, if_is_parent=True, max_depth=10):
     if o == parent and if_is_parent:
@@ -1234,8 +1472,9 @@ def is_or_has_parent(o, parent, if_is_parent=True, max_depth=10):
             return False
     return False
 
+
 def parent_to_curve(o, c):
-    o.parent_type = 'OBJECT'
+    o.parent_type = "OBJECT"
     o.parent = c
     # o.matrix_parent_inverse = c.matrix_world.inverted()
 
@@ -1244,13 +1483,15 @@ def parent_to_curve(o, c):
             i = -1 if c.data.splines[0].use_cyclic_u else 0
             p = c.data.splines[0].bezier_points[i].co
             o.matrix_parent_inverse.translation = p * -1.0
-        elif c.data.splines[0].type == 'NURBS':
+        elif c.data.splines[0].type == "NURBS":
             cm = c.to_mesh()
             p = cm.vertices[0].co
             o.matrix_parent_inverse.translation = p * -1.0
 
 
-def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4, can_regenerate=False):
+def set_text_on_curve(
+    text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4, can_regenerate=False
+):
     """set_text_on_curve
 
     An earlier reset cancels the other.
@@ -1271,10 +1512,11 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
     mom = text_properties.text_object
     if mom.type != "CURVE":
         return False
+    if len(mom.users_collection) < 1:
+        return False
 
     distribution_type = "CALCULATE" if is_bezier(mom) else "FOLLOW_PATH"
 
-
     # NOTE: following not necessary anymore
     # as we fixed data_path with parent_to_curve trick
     #
@@ -1330,10 +1572,9 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
 
         ############### GET GLYPH
 
-        glyph_tmp = Font.get_glyph(text_properties.font_name,
+        glyph_tmp = Font.get_glyph(
-                                   text_properties.face_name,
+            text_properties.font_name, text_properties.face_name, glyph_id, -1
-                                   glyph_id,
+        )
-                                   -1)
         if glyph_tmp is None:
             space_width = Font.is_space(glyph_id)
             if space_width:
@@ -1348,7 +1589,7 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
                     text_properties.font_name,
                     text_properties.face_name,
                     possible_replacement,
-                    -1
+                    -1,
                 )
                 if glyph_tmp is not None:
                     message = message + f" (replaced with '{possible_replacement}')"
@@ -1368,7 +1609,11 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
 
         ############### GLYPH PROPERTIES
 
-        glyph_properties = text_properties.glyphs[glyph_index] if not regenerate else text_properties.glyphs.add()
+        glyph_properties = (
+            text_properties.glyphs[glyph_index]
+            if not regenerate
+            else text_properties.glyphs.add()
+        )
 
         if regenerate:
             glyph_properties["glyph_id"] = glyph_id
@@ -1383,14 +1628,16 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
         if regenerate:
             outer_node = bpy.data.objects.new(f"{glyph_id}", None)
             inner_node = bpy.data.objects.new(f"{glyph_id}_mesh", glyph.data)
-            transfer_properties_to_glyph_object(text_properties, glyph_properties, outer_node)
+            transfer_properties_to_glyph_object(
+                text_properties, glyph_properties, outer_node
+            )
 
             # Add into the scene.
             mom.users_collection[0].objects.link(outer_node)
             mom.users_collection[0].objects.link(inner_node)
 
             # Parenting is hard.
-            inner_node.parent_type = 'OBJECT'
+            inner_node.parent_type = "OBJECT"
             inner_node.parent = outer_node
             inner_node.matrix_parent_inverse = outer_node.matrix_world.inverted()
             parent_to_curve(outer_node, mom)
@@ -1426,7 +1673,9 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
             outer_node.constraints.new(type="FOLLOW_PATH")
             outer_node.constraints["Follow Path"].target = mom
             outer_node.constraints["Follow Path"].use_fixed_location = True
-            outer_node.constraints["Follow Path"].offset_factor = applied_advance / curve_length
+            outer_node.constraints["Follow Path"].offset_factor = (
+                applied_advance / curve_length
+            )
             outer_node.constraints["Follow Path"].use_curve_follow = True
             outer_node.constraints["Follow Path"].forward_axis = "FORWARD_X"
             outer_node.constraints["Follow Path"].up_axis = "UP_Y"
@@ -1442,7 +1691,9 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
                 previous_inner_node_rotation_mode = inner_node.rotation_mode
 
             # get info from bezier
-            location, tangent, spline_index = calc_point_on_bezier_curve(mom, applied_advance, True, True)
+            location, tangent, spline_index = calc_point_on_bezier_curve(
+                mom, applied_advance, True, True
+            )
 
             # check if we are on a new line
             if spline_index != previous_spline_index:
@@ -1457,13 +1708,19 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
             vectors = [tangent]
             factors = [1.0]
             local_main_axis = mathutils.Vector((1.0, 0.0, 0.0))
-            motor = align_rotations_auto_pivot(
+            motor = (
+                align_rotations_auto_pivot(
                     mask, input_rotations, vectors, factors, local_main_axis
-            ) if not text_properties.ignore_orientation else [mathutils.Matrix()]
+                )
+                if not text_properties.ignore_orientation
+                else [mathutils.Matrix()]
+            )
 
             q = mathutils.Quaternion()
             q.rotate(text_properties.orientation)
-            outer_node.rotation_quaternion = (motor[0].to_3x3() @ q.to_matrix()).to_quaternion()
+            outer_node.rotation_quaternion = (
+                motor[0].to_3x3() @ q.to_matrix()
+            ).to_quaternion()
 
             # # NOTE: supercool but out of scope, as we wouldhave to update it everytime the curve object rotates,
             # # but this would ignore the curve objects orientation:
@@ -1482,16 +1739,16 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
         ############### PREPARE FOR THE NEXT
 
         glyph_advance = (
-            glyph_post_advance * scalor + text_properties.letter_spacing + glyph_properties.letter_spacing
+            glyph_post_advance * scalor
+            + text_properties.letter_spacing
+            + glyph_properties.letter_spacing
         )
 
         # now we need to compensate for curvature
         # otherwise letters will be closer together the curvier the bezier is
         # NOTE: this could be done more efficiently
         curve_compensation = 0
-        if distribution_type == "CALCULATE" and (
+        if distribution_type == "CALCULATE" and (not is_newline or spline_index == 0):
-            not is_newline or spline_index == 0
-        ):
             if text_properties.compensate_curvature and glyph_advance > 0:
                 previous_location, psi = calc_point_on_bezier_curve(
                     mom, advance, False, True
@@ -1503,8 +1760,10 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
                     n_max = 100
                     n = 0
                     while (
-                        previous_location - new_location
+                        (previous_location - new_location).length > glyph_advance
-                    ).length > glyph_advance and psi == si and n < n_max:
+                        and psi == si
+                        and n < n_max
+                    ):
                         curve_compensation = curve_compensation - glyph_advance * 0.01
                         tmp_new_location, si = calc_point_on_bezier_curve(
                             mom,
@@ -1513,14 +1772,18 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
                             output_spline_index=True,
                         )
                         if tmp_new_location == new_location:
-                            print(f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome")
+                            print(
+                                f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome"
+                            )
                             break
                         new_location = tmp_new_location
                         n += 1
                     n = 0
                     while (
-                        previous_location - new_location
+                        (previous_location - new_location).length < glyph_advance
-                    ).length < glyph_advance and psi == si and n < n_max:
+                        and psi == si
+                        and n < n_max
+                    ):
                         curve_compensation = curve_compensation + glyph_advance * 0.01
                         tmp_new_location, si = calc_point_on_bezier_curve(
                             mom,
@@ -1529,7 +1792,9 @@ def set_text_on_curve(text_properties, reset_timeout_s=0.1, reset_depsgraph_n=4,
                             output_spline_index=True,
                         )
                         if tmp_new_location == new_location:
-                            print(f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome")
+                            print(
+                                f"{utils.prefix()}::set_text_on_curve::compensate_curvature while loop overstaying welcome"
+                            )
                             break
                         new_location = tmp_new_location
                         n += 1
@@ -1932,6 +2197,7 @@ def align_metrics_of_objects(objects=None):
         add_metrics_obj_from_bound_box(t, bound_box)
     return ""
 
+
 def align_origins_to_active_object(objects=None, axis=2):
     if objects is None:
         objects = bpy.context.selected_objects
@@ -1957,6 +2223,7 @@ def align_origins_to_active_object(objects=None, axis=2):
 
     return ""
 
+
 # NOTE:
 # Following code is not necessary anymore,
 # as we derive the advance through metrics
@@ -2037,4 +2304,3 @@ def align_origins_to_active_object(objects=None, axis=2):
 # c.location -= mathutils.Vector((diff, 0.0, 0.0)) @ o.matrix_world.inverted()
 
 # return ""
-

common/Font.py

@@ -1,6 +1,5 @@
-from typing import Dict
 from pathlib import Path
-from typing import NamedTuple
+from typing import Dict, NamedTuple
 
 # convenience dictionary for translating names to glyph ids
 # note: overwritten/extended by the content of "glypNamesToUnicode.txt"
@@ -161,7 +160,6 @@ class Font:
         self.faces = faces
 
 
-
 def register_font(font_name, face_name, glyphs_in_fontfile, filepath):
     if not fonts.keys().__contains__(font_name):
         fonts[font_name] = Font({})
@@ -250,7 +248,10 @@ def get_glyphs(font_name, face_name, glyph_id):
     face = get_font_face(font_name, face_name)
     if face is None:
         print(f"ABC3D::get_glyph: font({font_name}) face({face_name}) not found")
+        try:
             print(fonts[font_name].faces.keys())
+        except:
+            print(fonts.keys())
         return []
 
     glyphs_for_id = face.glyphs.get(glyph_id)
@@ -291,6 +292,19 @@ def get_glyph(font_name, face_name, glyph_id, alternate=0):
     return glyphs[alternate]
 
 
+def unloaded_glyph(font_name, face_name, glyph_id):
+    face = get_font_face(font_name, face_name)
+    if face is None:
+        print(f"ABC3D::get_glyph: font({font_name}) face({face_name}) not found")
+        return
+    while True:
+        try:
+            fonts[font_name].faces[face_name].loaded_glyphs.remove(glyph_id)
+            del fonts[font_name].faces[face_name].glyphs[glyph_id]
+        except ValueError:
+            break
+
+
 class GlyphsAvailability(NamedTuple):
     loaded: str
     missing: str

common/utils.py

@@ -8,11 +8,11 @@ def get_version_minor():
 
 
 def get_version_patch():
-    return 10
+    return 11
 
 
 def get_version_string():
-    return f"{get_version_major()}.{get_version_minor()}.{get_version_patch}"
+    return f"{get_version_major()}.{get_version_minor()}.{get_version_patch()}"
 
 
 def prefix():
@@ -23,7 +23,6 @@ import datetime
 import time
 
 
-
 def get_timestamp():
     return datetime.datetime.fromtimestamp(time.time()).strftime("%Y.%m.%d-%H:%M:%S")
 
@@ -93,13 +92,17 @@ def printerr(*args, **kwargs):
 def removeNonAlphabetic(s):
     return "".join([i for i in s if i.isalpha()])
 
-import pathlib
+
 import os
+import pathlib
+
 
 def can_create_path(path_str: str):
     path = pathlib.Path(path_str).absolute().resolve()
 
-    while True: # this looks dangerours, but it actually is not
+    tries = 0
+    maximum_tries = 1000
+    while True:
         if path.exists():
             if os.access(path, os.W_OK):
                 return True
@@ -111,7 +114,11 @@ def can_create_path(path_str : str):
             return False
 
         path = path.parent
-
+        tries += 1
+        if tries > maximum_tries:
+            # always, always break out of while loops eventually
+            # IF you don't want to be here forever
+            break
 
 
 # # Evaluate a bezier curve for the parameter 0<=t<=1 along its length

requirements.txt

@@ -1,33 +1,39 @@
-astroid==3.3.5
+asttokens==3.0.0
-attrs==24.2.0
+attrs==25.3.0
-black==24.10.0
+bpy==4.4.0
-bpy==4.2.0
+cattrs==24.1.3
-cattrs==24.1.2
+certifi==2025.4.26
-certifi==2024.8.30
+charset-normalizer==3.4.2
-charset-normalizer==3.4.0
+Cython==3.1.1
-click==8.1.7
+decorator==5.2.1
-Cython==3.0.11
+docstring-to-markdown==0.17
-dill==0.3.9
+executing==2.2.0
-docstring-to-markdown==0.15
-flake8==7.1.1
 idna==3.10
-isort==5.13.2
+importlib_metadata==8.7.0
-jedi==0.19.1
+ipython==9.2.0
-jedi-language-server==0.41.4
+ipython_pygments_lexers==1.1.1
+jedi==0.19.2
+jedi-language-server==0.45.1
 lsprotocol==2023.0.1
 mathutils==3.3.0
-mccabe==0.7.0
+matplotlib-inline==0.1.7
-mypy-extensions==1.0.0
+numpy==1.26.4
-numpy==2.1.3
-packaging==24.1
 parso==0.8.4
-pathspec==0.12.1
+pexpect==4.9.0
-platformdirs==4.3.6
+pluggy==1.6.0
-pycodestyle==2.12.1
+prompt_toolkit==3.0.51
-pyflakes==3.2.0
+ptyprocess==0.7.0
+pure_eval==0.2.3
 pygls==1.3.1
-pylint==3.3.1
+Pygments==2.19.1
+python-jsonrpc-server==0.4.0
+python-lsp-jsonrpc==1.1.2
 requests==2.32.3
-tomlkit==0.13.2
+stack-data==0.6.3
-urllib3==2.2.3
+traitlets==5.14.3
+typing_extensions==4.13.2
+ujson==5.10.0
+urllib3==2.4.0
+wcwidth==0.2.13
+zipp==3.22.0
 zstandard==0.23.0

testing_scripts/bezier_distance.py

@@ -0,0 +1,25 @@
+import bpy
+from mathutils import *
+from math import *
+import abc3d.butils
+
+v = 0
+goal = 5.0
+step = 0.1
+speed = 1.0
+
+C = bpy.context
+obj = C.scene.objects['Cube']
+curve = C.scene.objects['BézierCurve']
+
+m = curve.matrix
+
+def fun(distance):
+    obj.location = m @ abc3d.butils.calc_point_on_bezier_curve(curve,
+                                                                distance,
+                                                                output_tangent=True)
+    print(f"executed {distance}")
+
+while v < goal:
+    bpy.app.timers.register(lambda: fun(v), first_interval=(v * speed))
+    v += step

testing_scripts/unload_glyphs.py

@@ -0,0 +1,115 @@
+import bpy
+
+import abc3d
+from abc3d import butils
+from abc3d.common import Font
+
+
+def get_text_properties_by_mom(mom):
+    scene = bpy.context.scene
+    abc3d_data = scene.abc3d_data
+
+    for text_properties in abc3d_data.available_texts:
+        if mom == text_properties.text_object:
+            return text_properties
+    return None
+
+
+def isolate_objects(objects):
+    for area in bpy.context.window.screen.areas:
+        if area.type == "VIEW_3D":
+            with bpy.context.temp_override(
+                selected_objects=list(objects),
+                area=area,
+                refgion=[region for region in area.regions if region.type == "WINDOW"][
+                    0
+                ],
+                screen=bpy.context.window.screen,
+            ):
+                # bpy.ops.view3d.view_selected()
+                bpy.ops.view3d.localview(frame_selected=True)
+                break
+
+
+def main():
+    # create a curve
+    bpy.ops.curve.primitive_bezier_curve_add(
+        radius=1,
+        enter_editmode=False,
+        align="WORLD",
+        location=(0, 0, 0),
+        scale=(1, 1, 1),
+    )
+    # new curve is active object
+    mom = bpy.context.active_object
+
+    # make sure
+    print(f"MOM: {mom.name}")
+
+    fonts = Font.get_loaded_fonts_and_faces()
+    if len(fonts) == 0:
+        print("no fonts! what?")
+        return
+
+    font_name = fonts[0][0]
+    face_name = fonts[0][1]
+    font = f"{font_name} {face_name}"
+
+    isolate_objects([mom])
+
+    bpy.ops.abc3d.placetext(
+        font_name=font_name,
+        face_name=face_name,
+        font=font,
+        text="SOMETHING SOMETHING BROKEN ARMS",
+        letter_spacing=0,
+        font_size=1,
+        offset=0,
+        translation=(0, 0, 0),
+        orientation=(1.5708, 0, 0),
+    )
+
+    def change_text(font_name="", face_name="", text=""):
+        print(f"change_text to '{text}'")
+        text_properties = get_text_properties_by_mom(mom)
+        if font_name != "":
+            text_properties["font_name"] = font_name
+        if face_name != "":
+            text_properties["face_name"] = face_name
+        if text != "":
+            text_properties.text = text
+        else:
+            text_properties.text = text_properties.text
+        return None
+
+    def unload(glyph_id):
+        print(f"unload glyph '{glyph_id}'")
+        butils.unload_unused_glyph(font_name, face_name, glyph_id)
+        return None
+
+    def unload_all():
+        print(f"unload glyph all unused glyphs")
+        butils.unload_unused_glyphs()
+        return None
+
+    bpy.app.timers.register(lambda: change_text(text="SOMETHING"), first_interval=0)
+    bpy.app.timers.register(lambda: change_text(text="LOLSS"), first_interval=2)
+    bpy.app.timers.register(lambda: change_text(text="LOLAA"), first_interval=3)
+    bpy.app.timers.register(lambda: change_text(text="WHAT"), first_interval=4)
+    bpy.app.timers.register(lambda: change_text(text="LOL"), first_interval=5)
+
+    bpy.app.timers.register(lambda: unload("A"), first_interval=10)
+    bpy.app.timers.register(lambda: unload_all(), first_interval=12)
+
+    bpy.app.timers.register(lambda: change_text(text="LOLM"), first_interval=16)
+    bpy.app.timers.register(lambda: change_text(text="ZHE END"), first_interval=20)
+
+    bpy.app.timers.register(
+        lambda: change_text(font_name="NM_Origin", face_name="Tender"),
+        first_interval=30,
+    )
+
+    bpy.app.timers.register(lambda: unload_all(), first_interval=42)
+
+
+main()