font3d_blender_addon/__init__.py

# SPDX-License-Identifier: GPL-2.0-only

"""
A 3D font helper
"""

bl_info = {
    "name": "Font3D",
    "author": "Jakob Schlötter, Studio Pointer*",
    "version": (0, 0, 1),
    "blender": (4, 1, 0),
    "location": "VIEW3D",
    "description": "Does Font3D stuff",
    "category": "Typography",
}

# make sure that modules are reloadable
# when registering
# handy for development
# first import dependencies for the method
import importlib

# then import dependencies for our addon
if "bpy" in locals():
    importlib.reload(Font)
    importlib.reload(utils)
    importlib.reload(butils)
else:
    from .common import Font
    from .common import utils
    from . import butils

import bpy
import math
import mathutils
import io
import functools
from bpy.types import Panel
from bpy.app.handlers import persistent
from random import uniform

import time
import datetime

import os
import re

def getPreferences(context):
    preferences = context.preferences
    return preferences.addons[__name__].preferences

class FONT3D_addonPreferences(bpy.types.AddonPreferences):
    """Font3D Addon Preferences

    These are the preferences at Edit/Preferences/Add-ons"""

    bl_idname = __name__

    def get_default_assets_dir():
        return bpy.utils.user_resource(
                'DATAFILES',
                path=f"{__name__}",
                create=True)

    def on_change_assets_dir(self, context):
        if not os.path.isdir(self.assets_dir):
           butils.ShowMessageBox(
                   title=f"{__name__} Warning",
                   icon="ERROR",
                   message=("Chosen directory does not exist.",
                            "Please, reset to default, create it or chose another one."))
        elif not os.access(self.assets_dir, os.W_OK):
           butils.ShowMessageBox(
                   title=f"{__name__} Warning",
                   icon="ERROR",
                   message=("Chosen directory is not writable.",
                            "Please reset to default or chose another one."))

        print(f"{__name__}: change assets_dir to {self.assets_dir}")

    assets_dir: bpy.props.StringProperty(
            name="Assets Folder",
            subtype='DIR_PATH',
            default=get_default_assets_dir(),
            update=on_change_assets_dir,
            )

    def draw(self, context):
        layout = self.layout
        layout.label(text="Directory for storage of fonts and other assets:")
        layout.prop(self, "assets_dir")


class FONT3D_settings(bpy.types.PropertyGroup):
    font_path: bpy.props.StringProperty(
            name="Font path",
            description="Load a *.glb or *.gltf fontfile from disk",
            default="",
            maxlen=1024,
            subtype="FILE_PATH")
    import_infix: bpy.props.StringProperty(
            name="Font name import infix",
            description="The infix which all font objects to import have. obj name: 'A_NM_Origin_Tender' -> infix: '_NM_Origin_Tender'",
            default="_NM_",
            maxlen=1024,
            )
    text: bpy.props.StringProperty(
            name="Text",
            description="The text.",
            default="HELLO",
            maxlen=1024,
            )
    target_object: bpy.props.PointerProperty(
            name="The Target Object",
            description="The target, which will be populated by character children of text.",
            type=bpy.types.Object,
            )
    letter_spacing: bpy.props.FloatProperty(
            name="Letter Spacing",
            description="Letter Spacing",
            default=0.0,
            )
    font_size: bpy.props.FloatProperty(
            name="Font Size",
            default=1.0,
            subtype='NONE',
            )
    translation: bpy.props.FloatVectorProperty(
            name="Translation",
            default=(0.0, 0.0, 0.0),
            subtype='TRANSLATION',
            )
    orientation: bpy.props.FloatVectorProperty(
            name="Orientation",
            default=(1.5707963267948966, 0.0, 0.0), # 90 degrees in radians
            subtype='EULER',
            )

class FONT3D_available_font(bpy.types.PropertyGroup):
    font_name: bpy.props.StringProperty(name="")
    face_name: bpy.props.StringProperty(name="")

class FONT3D_glyph_properties(bpy.types.PropertyGroup):
    glyph_id: bpy.props.StringProperty(maxlen=1)
    glyph_object: bpy.props.PointerProperty(type=bpy.types.Object)
    letter_spacing: bpy.props.FloatProperty(
            name="Letter Spacing",
            description="Letter Spacing",
            )

class FONT3D_text_properties(bpy.types.PropertyGroup):
    def update_callback(self, context):
        butils.set_text_on_curve(self)
    text_id: bpy.props.IntProperty()
    font_name: bpy.props.StringProperty()
    font_face: bpy.props.StringProperty()
    text_object: bpy.props.PointerProperty(type=bpy.types.Object)
    text: bpy.props.StringProperty(
            update=update_callback
            )
    letter_spacing: bpy.props.FloatProperty(
            update=update_callback,
            name="Letter Spacing",
            description="Letter Spacing",
            options={'ANIMATABLE'},
            step=0.01,
            )
    orientation: bpy.props.FloatVectorProperty(
            update=update_callback,
            name="Orientation",
            default=(1.5707963267948966, 0.0, 0.0), # 90 degrees in radians
            subtype='EULER',
            )
    translation: bpy.props.FloatVectorProperty(
            update=update_callback,
            name="Translation",
            default=(0.0, 0.0, 0.0),
            subtype='TRANSLATION',
            )
    font_size: bpy.props.FloatProperty(
            update=update_callback,
            name="Font Size",
            default=1.0,
            subtype='NONE',
            )
    compensate_curvature: bpy.props.BoolProperty(
            update=update_callback,
            name="Compensate Curvature",
            default=True,
    )
    ignore_orientation: bpy.props.BoolProperty(
            update=update_callback,
            name="Ignore Orientation",
            default=False,
    )
    distribution_type: bpy.props.StringProperty()
    glyphs: bpy.props.CollectionProperty(type=FONT3D_glyph_properties)

#TODO: simply, merge, cut cut cut
class FONT3D_data(bpy.types.PropertyGroup):
    available_fonts: bpy.props.CollectionProperty(type=FONT3D_available_font, name="name of the collection property")
    active_font_index: bpy.props.IntProperty()
    available_texts: bpy.props.CollectionProperty(type=FONT3D_text_properties, name="")
    def active_text_index_update(self, context):
        if self.active_text_index != -1:
            o = self.available_texts[self.active_text_index].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 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)
                bpy.context.view_layer.objects.active = o
            # else:
                # print("already selected")

    active_text_index: bpy.props.IntProperty(update=active_text_index_update)

class FONT3D_UL_fonts(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        layout.label(text=f"{index}: {item.font_name} {item.face_name}") # avoids renaming the item by accident

    def invoke(self, context, event):
        pass

class FONT3D_UL_texts(bpy.types.UIList):
    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
        split = layout.split(factor=0.3)
        split.label(text="Id: %d" % (item.text_id))
        split.label(text=f"{item.text}") # avoids renaming the item by accident

    def invoke(self, context, event):
        pass

class FONT3D_PT_Panel(bpy.types.Panel):
    bl_label = f"{__name__} panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    def draw(self, context):
        layout = self.layout

        layout.label(text=f"{__name__} panel")


class FONT3D_PT_LoadFontPanel(bpy.types.Panel):
    bl_label = "Load a new font"
    bl_parent_id = "FONT3D_PT_Panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_options = {"DEFAULT_CLOSED"}

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        scene = context.scene

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        layout.label(text="Load FontFile:")
        layout.row().prop(font3d, "font_path")
        layout.row().operator('font3d.loadfont', text='Load Font')


class FONT3D_PT_FontList(bpy.types.Panel):
    bl_label = "Font List"
    bl_parent_id = "FONT3D_PT_Panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        scene = context.scene

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        layout.label(text="Loaded Fonts")
        layout.template_list("FONT3D_UL_fonts", "", font3d_data, "available_fonts", font3d_data, "active_font_index")

class FONT3D_PT_TextPlacement(bpy.types.Panel):
    bl_label = "Place Text"
    bl_parent_id = "FONT3D_PT_Panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    can_place = False

    @classmethod
    def poll(self, context):
        if type(context.active_object) != type(None) and context.active_object.type == 'CURVE':
            self.can_place = True
        else:
            self.can_place = False
        return True

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        scene = context.scene

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        layout.label(text="Set Properties Objects")
        layout.row().prop(font3d, "text")
        layout.row().prop(font3d, "letter_spacing")
        layout.row().prop(font3d, "font_size")
        layout.column().prop(font3d, "translation")
        layout.column().prop(font3d, "orientation")
        placerow = layout.row()
        placerow.enabled = self.can_place
        placerow.operator(f"{__name__}.placetext", text='Place Text')
        if not self.can_place:
            layout.label(text="Cannot place Text.")
            layout.label(text="Select a curve as active object.")

class FONT3D_PT_TextManagement(bpy.types.Panel):
    bl_label = "Text Management"
    bl_parent_id = "FONT3D_PT_Panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    # TODO: perhaps this should be done in a periodic timer
    @classmethod
    def poll(self, context):
        scene = context.scene
        font3d = scene.font3d
        font3d_data = scene.font3d_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(font3d_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 (c.get('linked_textobject')) != type(None) and c.get('linked_textobject') == 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:
                font3d_data.available_texts.remove(i)

            for i, t in enumerate(font3d_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 != font3d_data.active_text_index:
                font3d_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
        scene = context.scene

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        layout.label(text="Text Objects")
        layout.template_list("FONT3D_UL_texts", "", font3d_data, "available_texts", font3d_data, "active_text_index")

class FONT3D_PT_FontCreation(bpy.types.Panel):
    bl_label = "Font Creation"
    bl_parent_id = "FONT3D_PT_Panel"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_options = {"DEFAULT_CLOSED"}

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        scene = context.scene

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        layout.row().label(text="Font name import infix:")
        layout.row().prop(font3d, "import_infix", text="")
        layout.row().operator('font3d.create_font_from_objects', text='Create Font')
        layout.row().operator('font3d.save_font_to_file', text='Save Font To File')
        layout.row().operator('font3d.toggle_font3d_collection', text='Toggle Collection')
        box = layout.box()
        box.label(text="metrics")
        box.row().operator(f"{__name__}.add_default_metrics", text='Add Default Metrics')
        box.row().operator(f"{__name__}.remove_metrics", text='Remove Metrics')
        box.row().operator(f"{__name__}.align_metrics", text='Align Metrics')
        box.row().operator(f"{__name__}.align_metrics_to_active_object", text='Align Metrics to Active Object')
        layout.row().operator('font3d.temporaryhelper', text='Debug Function Do Not Use')

class FONT3D_PT_TextPropertiesPanel(bpy.types.Panel):
    bl_label = "Text Properties"
    bl_parent_id = "FONT3D_PT_TextManagement"
    bl_category = "Font3D"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"

    def get_active_text_properties(self):
        if type(bpy.context.active_object) != type(None):# and bpy.context.object.select_get():
            for t in bpy.context.scene.font3d_data.available_texts:
                if bpy.context.active_object == t.text_object:
                    return t
                if bpy.context.active_object.parent == t.text_object:
                    return t
        return None

    @classmethod
    def poll(self,context):
        return type(self.get_active_text_properties(self)) != type(None)

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        scene = context.scene
        font3d = scene.font3d
        font3d_data = scene.font3d_data

        props = self.get_active_text_properties()

        if type(props) == type(None) or type(props.text_object) == type(None):
            # this should not happen
            # as then polling does not work
            # however, we are paranoid
            return
        
        layout.label(text=f"Mom: {props.text_object.name}")
        layout.row().prop(props, "text")
        layout.row().prop(props, "letter_spacing")
        layout.row().prop(props, "font_size")
        layout.row().prop(props, "compensate_curvature")
        layout.row().prop(props, "ignore_orientation")
        layout.column().prop(props, "translation")
        layout.column().prop(props, "orientation")

class FONT3D_OT_LoadFont(bpy.types.Operator):
    """Load Fontfile from path above.
(Format must be *.glb or *.gltf)"""
    bl_idname = f"{__name__}.loadfont"
    bl_label = "Load Font"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        scene = bpy.context.scene

        butils.ShowMessageBox(
            title=f"{__name__} Warning",
            icon="ERROR",
            message=f"We believe this functionality is currently not available.",
            )
        return {'CANCELLED'}

        if not os.path.exists(scene.font3d.font_path):
            butils.ShowMessageBox(
                title=f"{__name__} Warning",
                icon="ERROR",
                message=f"We believe the font path ({scene[__name__].font_path}) does not exist.",
                )
            return {'CANCELLED'}

        butils.load_font_from_filepath(scene.font3d.font_path)

        return {'FINISHED'}

class FONT3D_OT_AddDefaultMetrics(bpy.types.Operator):
    """Add default metrics to selected objects"""
    bl_idname = f"{__name__}.add_default_metrics"
    bl_label = "Add default metrics"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        objects = bpy.context.selected_objects
        butils.add_default_metrics_to_objects(objects)
        return {'FINISHED'}

class FONT3D_OT_RemoveMetrics(bpy.types.Operator):
    """Remove metrics from selected objects"""
    bl_idname = f"{__name__}.remove_metrics"
    bl_label = "Remove metrics"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        objects = bpy.context.selected_objects
        butils.remove_metrics_from_objects(objects)
        return {'FINISHED'}

class FONT3D_OT_AlignMetricsToActiveObject(bpy.types.Operator):
    """Align metrics of selected objects to metrics of active object"""
    bl_idname = f"{__name__}.align_metrics_to_active_object"
    bl_label = "Align metrics to active object"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        objects = bpy.context.selected_objects
        butils.align_metrics_of_objects_to_active_object(objects)
        return {'FINISHED'}

class FONT3D_OT_AlignMetrics(bpy.types.Operator):
    """Align metrics of selected objects to each other"""
    bl_idname = f"{__name__}.align_metrics"
    bl_label = "Align metrics"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        objects = bpy.context.selected_objects
        butils.align_metrics_of_objects(objects)
        return {'FINISHED'}

class FONT3D_OT_TemporaryHelper(bpy.types.Operator):
    """Temp Font 3D"""
    bl_idname = f"{__name__}.temporaryhelper"
    bl_label = "Temp Font"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        global shared
        scene = bpy.context.scene
        font3d_data = scene.font3d_data

        objects = bpy.context.selected_objects
        butils.add_default_metrics_to_objects(objects)
        # reference_bound_box = None
        # for o in objects:
            # bb = o.bound_box
            # reference_bound_box = butils.get_max_bound_box(bb, reference_bound_box)
        # for o in objects:
            # metrics = butils.get_metrics_bound_box(o.bound_box, reference_bound_box)
            # butils.add_metrics_obj_from_bound_box(o, metrics)
        # bpy.app.timers.register(lambda: butils.remove_metrics_from_objects(objects), first_interval=5)

        return {'FINISHED'}

class FONT3D_OT_PlaceText(bpy.types.Operator):
    """Place Text 3D on active object"""
    bl_idname = f"{__name__}.placetext"
    bl_label = "Place Text"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        global shared
        scene = bpy.context.scene

        selected = bpy.context.view_layer.objects.active

        font3d = scene.font3d
        font3d_data = scene.font3d_data

        if font3d.target_object:
            selected = font3d.target_object

        if selected:
            font_name = "NM_Origin"
            font_face = "Tender"

            distribution_type = 'DEFAULT'

            text_id = 0
            for i, tt in enumerate(font3d_data.available_texts):
                while text_id == tt.text_id:
                    text_id = text_id + 1
            t = font3d_data.available_texts.add()
            t.text_id = text_id

            t.font_name = font_name
            t.font_face = font_face
            t.text_object = selected
            t.text = scene.font3d.text
            t.letter_spacing = scene.font3d.letter_spacing
            t.font_size = scene.font3d.font_size
            t.translation = scene.font3d.translation
            t.orientation = scene.font3d.orientation
            t.distribution_type = distribution_type
        else:
            butils.ShowMessageBox(
                    title="No object selected",
                    message=(
                        "Please select an object.",
                        "It will be used to put the type on.",
                        "Thank you :)"),
                    icon='GHOST_ENABLED')

        return {'FINISHED'}

class FONT3D_OT_ToggleFont3DCollection(bpy.types.Operator):
    """Toggle Font3D Collection"""
    bl_idname = f"{__name__}.toggle_font3d_collection"
    bl_label = "Toggle Collection visibility"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        scene = context.scene
        fontcollection = bpy.data.collections.get("Font3D")

        if fontcollection is None:
            self.report({'INFO'}, f"{bl_info['name']}: There is no collection")
        elif scene.collection.children.find(fontcollection.name) < 0:
            scene.collection.children.link(fontcollection)
            self.report({'INFO'}, f"{bl_info['name']}: show collection")
        else:
            scene.collection.children.unlink(fontcollection)
            self.report({'INFO'}, f"{bl_info['name']}: hide collection")

        return {'FINISHED'}


class FONT3D_OT_SaveFontToFile(bpy.types.Operator):
    """Save font to file"""
    bl_idname = f"{__name__}.save_font_to_file"
    bl_label = "Save Font"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        global shared
        scene = bpy.context.scene
        font3d_data = scene.font3d_data
        font3d = scene.font3d

        fontcollection = bpy.data.collections.get("Font3D")

        # check if all is good to proceed
        if fontcollection is None:
            self.report({'INFO'}, f"{bl_info['name']}: There is no collection")
            return {'CANCELLED'}

        if font3d_data.active_font_index < 0:
            self.report({'INFO'}, f"{bl_info['name']}: There is no active font")
            return {'CANCELLED'}

        if len(font3d_data.available_fonts) <= font3d_data.active_font_index:
            self.report({'INFO'}, f"{bl_info['name']}: Active font is not available")
            return {'CANCELLED'}

        # save state to restore later
        was_fontcollection_linked = scene.collection.children.find(fontcollection.name) >= 0
        was_selection = []
        for obj in bpy.context.selected_objects:
            was_selection.append(obj)
        was_active_object = bpy.context.view_layer.objects.active

        bpy.ops.object.select_all(action="DESELECT")

        # get save data
        selected_font = font3d_data.available_fonts[font3d_data.active_font_index]

        # print(selected_font.font_name)
        self.report({'INFO'}, f"{bl_info['name']}: {selected_font.font_name} {selected_font.face_name}")
        preferences = getPreferences(context)
        print(f"assets folder: {preferences.assets_dir}")

        bpy.ops.scene.new(type='FULL_COPY')

        linked_collections = bpy.context.scene.collection.children.values()
        for c in linked_collections:
            bpy.context.scene.collection.children.unlink(c)
        bpy.context.scene.collection.children.link(fontcollection)

        # select what needs to be selected
        export_objects = []
        for obj in fontcollection.objects:
            if obj["font_name"] == selected_font.font_name:
                if not butils.is_metrics_object(obj):
                    # butils.add_faces_to_metrics(obj)
                    obj.select_set(True)
                    export_objects.append(obj)

        context_override = bpy.context.copy()
        context_override["selected_objects"] = list(export_objects)
        # context_override["scene"] = bpy.context.scene.copy()
        with bpy.context.temp_override(**context_override):
            filepath = f"{preferences.assets_dir}/fonts/{selected_font.font_name}.gltf"
            # get rid of scene extra data before export
            scene_keys = []
            for k in bpy.context.scene.keys():
                scene_keys.append(k)
            for k in scene_keys:
                del bpy.context.scene[k]

            # save as gltf
            bpy.ops.export_scene.gltf(
                filepath=filepath,
                check_existing=False,
                export_format='GLB', # GLB or GLTF_SEPARATE
                export_extras=True,
                # export_hierarchy_full_collections=True,
                # use_active_collection_with_nested=True,
                use_selection=True,
                use_active_scene=True,
            )
            # bpy.app.timers.register(lambda: bpy.ops.scene.delete(), first_interval=5)

            bpy.ops.scene.delete()
        # restore()

        for obj in fontcollection.objects:
            if obj["font_name"] == selected_font.font_name:
                if butils.is_metrics_object(obj):
                    butils.remove_faces_from_metrics(obj)
        self.report({'INFO'}, f"did it")

        return {'FINISHED'}
# keep = ['io_anim_bvh', 'io_curve_svg', 'io_mesh_stl', 'io_mesh_uv_layout', 'io_scene_fbx', 'io_scene_gltf2', 'io_scene_x3d', 'cycles', 'pose_library', 'font3d']
# for addon in keep:
    # bpy.ops.preferences.addon_enable(module=addon)


class FONT3D_OT_CreateFontFromObjects(bpy.types.Operator):
    """Create Font from selected objects"""
    bl_idname = f"{__name__}.create_font_from_objects"
    bl_label = "Create Font"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        global shared
        scene = bpy.context.scene
        font3d = scene.font3d
        font3d_data = scene.font3d_data

        fontcollection = bpy.data.collections.get("Font3D")

        if fontcollection is None:
            fontcollection = bpy.data.collections.new("Font3D")

        ifxsplit = font3d.import_infix.split('_')
        font_name = f"{ifxsplit[1]}_{ifxsplit[2]}"
        face_name = ifxsplit[3]

        added_font = False

        # TODO: do not clear
        font3d_data.available_fonts.clear()
        Font.fonts = {}
        currentObjects = []
        for o in context.selected_objects:
            if o.name not in currentObjects:
                if font3d.import_infix in o.name and not butils.is_metrics_obj(o):
                    uc = o.users_collection
                    regex = f"{font3d.import_infix}(.)*"
                    name = re.sub(regex, "", o.name) 
                    glyph_id = "unknown"
                    if len(name) == 1:
                        glyph_id = name
                    elif name in Font.name_to_glyph_d:
                        glyph_id = Font.name_to_glyph_d[name]

                    if glyph_id != "unknown":
                        o["glyph"] = glyph_id
                        o["font_name"] = font_name
                        o["face_name"] = face_name
                        # butils.apply_all_transforms(o)
                        butils.move_in_fontcollection(
                                o,
                                fontcollection)
                        Font.add_glyph(
                                font_name,
                                face_name,
                                glyph_id,
                                o)
                        added_font = True

                        #TODO: is there a better way to iterate over a CollectionProperty?
                        found = False
                        for f in font3d_data.available_fonts.values():
                            if f.font_name == font_name:
                                found = True
                                break
                        if not found:
                            f = font3d_data.available_fonts.add()
                            f.font_name = font_name

                    else:
                        self.report({'INFO'}, f"did not understand glyph {name}")

        return {'FINISHED'}

class FONT3D_PT_RightPropertiesPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = f"{bl_info['name']}"
    bl_idname = "FONT3D_PT_RightPropertiesPanel"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    @classmethod
    def poll(self,context):
        # only show the panel, if it's a textobject or a glyph
        is_text = type(next((t for t in context.scene.font3d_data.available_texts if t.text_object == context.active_object), None)) != type(None)
        is_glyph = type(next((t for t in context.scene.font3d_data.available_texts if t.text_object == context.active_object.parent), None)) != type(None)
        return is_text or is_glyph

    def draw(self, context):
        layout = self.layout
        scene = context.scene
        font3d = scene.font3d
        font3d_data = scene.font3d_data

        obj = context.active_object

        def is_it_text():
            return type(next((t for t in context.scene.font3d_data.available_texts if t.text_object == context.active_object), None)) != type(None)
        def is_it_glyph():
            return type(next((t for t in context.scene.font3d_data.available_texts if t.text_object == context.active_object.parent), None)) != type(None)

        is_text = is_it_text()
        is_glyph = is_it_glyph()

        textobject = obj if is_text else obj.parent if is_glyph else obj
        available_text = font3d_data.available_texts[font3d_data.active_text_index]

        # row = layout.row()
        # row.label(text="Hello world!", icon='WORLD_DATA')
        # row = layout.row()
        # row.label(text="Active object is: " + obj.name)
        # row = layout.row()
        # row.label(text="text object is: " + textobject.name)
        row = layout.row()
        row.label(text=f"active text index is: {font3d_data.active_text_index}")

        layout.row().label(text="Text Properties:")
        layout.row().prop(available_text, "text")
        layout.row().prop(available_text, "letter_spacing")
        layout.row().prop(available_text, "font_size")
        layout.row().prop(available_text, "compensate_curvature")
        layout.row().prop(available_text, "ignore_orientation")
        layout.column().prop(available_text, "translation")
        layout.column().prop(available_text, "orientation")

        if is_glyph:
            layout.row().label(text="Glyph Properties:")


classes = (
            FONT3D_addonPreferences,
            FONT3D_available_font,
            FONT3D_glyph_properties,
            FONT3D_text_properties,
            FONT3D_data,
            FONT3D_settings,
            FONT3D_UL_fonts,
            FONT3D_UL_texts,
            FONT3D_PT_Panel,
            FONT3D_PT_LoadFontPanel,
            FONT3D_PT_FontList,
            FONT3D_PT_TextPlacement,
            FONT3D_PT_TextManagement,
            FONT3D_PT_FontCreation,
            FONT3D_PT_TextPropertiesPanel,
            FONT3D_OT_AddDefaultMetrics,
            FONT3D_OT_RemoveMetrics,
            FONT3D_OT_AlignMetricsToActiveObject,
            FONT3D_OT_AlignMetrics,
            FONT3D_OT_TemporaryHelper,
            FONT3D_OT_PlaceText,
            FONT3D_OT_LoadFont,
            FONT3D_OT_ToggleFont3DCollection,
            FONT3D_OT_SaveFontToFile,
            FONT3D_OT_CreateFontFromObjects,
            FONT3D_PT_RightPropertiesPanel,
           )

@persistent
def load_handler(self, dummy):
    if not bpy.app.timers.is_registered(butils.execute_queued_functions):
        bpy.app.timers.register(butils.execute_queued_functions)

def load_handler_unload():
    if bpy.app.timers.is_registered(butils.execute_queued_functions):
        bpy.app.timers.unregister(butils.execute_queued_functions)

@persistent
def on_frame_changed(self, dummy):
    for t in bpy.context.scene.font3d_data.available_texts:
        # TODO PERFORMANCE: only on demand
        butils.set_text_on_curve(t)
    # for i, t in enumerate(bpy.context.scene.font3d_data.available_texts):
        # # TODO PERFORMANCE: only on demand
        # # butils.set_text_on_curve(t)
        # pass

def register():
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.font3d = bpy.props.PointerProperty(type=FONT3D_settings)
    bpy.types.Scene.font3d_data = bpy.props.PointerProperty(type=FONT3D_data)
    # bpy.types.Object.__del__ = lambda self: print(f"Bye {self.name}")
    print(f"REGISTER {bl_info['name']}")

    # auto start if we load a blend file
    if load_handler not in bpy.app.handlers.load_post:
        bpy.app.handlers.load_post.append(load_handler)
    # and autostart if we reload script
    load_handler(None, None)

    if on_frame_changed not in bpy.app.handlers.frame_change_post:
        bpy.app.handlers.frame_change_post.append(on_frame_changed)

    butils.run_in_main_thread(butils.clear_available_fonts)
    butils.run_in_main_thread(butils.load_available_fonts)

def unregister():
    for cls in classes:
        bpy.utils.unregister_class(cls)

    # remove autostart when loading blend file
    if load_handler in bpy.app.handlers.load_post:
        bpy.app.handlers.load_post.remove(load_handler)
    # and when reload script
    load_handler_unload()

    if on_frame_changed in bpy.app.handlers.frame_change_post:
        bpy.app.handlers.frame_change_post.remove(on_frame_changed)

    del bpy.types.Scene.font3d
    del bpy.types.Scene.font3d_data
    print(f"UNREGISTER {bl_info['name']}")

if __name__ == '__main__':
    register()