Source code for cgl.plugins.blender.custom_menu

import importlib
import logging
import os

from cgl.core.utils.general import load_json

try:
    import bpy
except ImportError:
    pass

from importlib import reload

import cgl.plugins.CustomMenu as cm
from cgl.core.config.query import AlchemyConfigManager
from cgl.core.utils.read_write import load_text_file, save_text_lines

reload(cm)




class Menu(cm.CustomMenu):
    def __init__(self, software="blender", type_="menus"):
        cm.CustomMenu.__init__(self, software, type_)
        self.cfg = AlchemyConfigManager()



    def create_menu(self, name, menu_type="panel"):
        """
        creates a menu with title of 'name'

        Args:
            name (str): name of the menu
            menu_type (str): type of menu to create.  Options are 'panel' or 'menu'

        """
        print("Creating Menu with name: ", name)
        menu_class = self.find_menu_by_name(name)
        try:
            bpy.utils.register_class(menu_class)
        except ValueError:
            logging.info("%s already registered" % name)




    def add_button(
        self,
        menu_label,
        label="",
        annotation="",
        command="",
        icon="",
        image_overlay_label="",
        hot_key="",
    ):
        """
        add a button to a menu

        Args:
            menu_label (str): name of the menu to add the button to (must already exist)
            label (str): label of the button
            annotation (str): annotation of the button
            command (str): command to run when button is clicked
            icon (str): icon to display on the button
            image_overlay_label (str): image_plane overlay label to display on the button
            hot_key (str): hot key to assign to the button

        """

        #  menu_path = f"{self.menus_folder}/{menu}/{label}.py"
        cmd = command.split(" ")[-1]
        module_name = cmd.split(".")[0]
        real_module_name = None
        menu_dir = os.path.join(self.menus_folder, menu_label)
        for file in os.listdir(menu_dir):
            if file.lower().startswith(module_name.lower()) and file.endswith(".py"):
                real_module_name = file.replace(".py", "")
                logging.info(real_module_name)
                break
        # module = menu_path.split("cookbook\\")[-1].replace("\\", ".").replace(".py", "")
        module = f"cookbook.blender.menus.{menu_label}.{module_name}"
        try:
            module_result = importlib.import_module(module)
            button_class = getattr(module_result, module_name)
            if button_class:
                try:
                    bpy.utils.register_class(button_class)
                    print(f"✅ Registered operator: {button_class.__name__}")
                    print("module: {0} found".format(module))
                except ValueError:
                    print(f"⚠️ Operator {button_class.__name__} already registered")
            else:
                print(f"❌ No operator class found in module: {module}")
        except ModuleNotFoundError:
            print("module: {0} not found".format(module))




    def find_menu_by_name(self, menu_name):
        """
        finds menu in software package given its string name

        Args:
            menu_name (str): name of the menu to find
        """
        if isinstance(menu_name, dict):
            menu_name = menu_name["name"]
            # menu_label = menu_name["label"]
        menu_path = os.path.join(self.menus_folder, menu_name).replace("\\", "/")
        module = menu_path.split("cookbook/")[-1].replace("/", ".").replace(".py", "")
        module = "cookbook.{}.{}".format(module, menu_name)
        # logging.info(module)
        module_result = importlib.import_module(module)
        try:
            menu_class = getattr(module_result, menu_name)
        except AttributeError:
            print("Could not find menu class for {0}".format(menu_name))
            return None
        return menu_class




    def delete_menu(self, menu_name):
        """
        deletes menu by "menu_name"

        Args:
            menu_name (str): name of the menu to delete
        """
        menu_class = self.find_menu_by_name(menu_name)
        if menu_class:
            try:
                bpy.utils.unregister_class(menu_class)
            except RuntimeError:
                logging.info(
                    "bpy.utils.unregister_class could not find {0}".format(menu_class)
                )






def add_operator_buttons_to_panel(panel_file="", prefix="alchemy"):
    """
    This function is used to add buttons to the panel in blender
    """

    filename = os.path.basename(panel_file).replace(".py", "")
    this_file = panel_file.split("menus")[0]
    menu_file_path = f"{this_file}menus.cgl"
    menus = load_json(menu_file_path)["blender"]
    ordered_buttons = []
    for m in menus:
        if m["name"] == filename:
            for i, button in enumerate(m["buttons"]):
                ordered_buttons.append(
                    ["{}.{}".format(prefix, button["name"].lower()), button["label"]]
                )
    return ordered_buttons





def get_blender_menu_file(cookbook_root, recipe_type, recipe_name):
    """
    This function gets the blender menu file
    """
    return (
        f"{cookbook_root}/cookbook/blender/{recipe_type}/{recipe_name}/{recipe_name}.py"
    )





def get_blender_button_template(cookbook_root, recipe_type):
    """
    This function gets the blender menu file template
    Args:
        recipe_type:
        recipe_name:

    Returns:

    """
    return f"{cookbook_root}/cookbook/templates/blender/buttons/for_{recipe_type}.py"





def get_blender_menu_template(cookbook_root):
    """
    This function gets the blender menu file template
    Args:
        cookbook_root:

    Returns:

    """
    return f"{cookbook_root}/cookbook/templates/blender/PanelTemplate.py"





def create_blender_menu_file(cookbook_root, recipe_type, recipe_name, recipe_label):
    """
    This function creates the blender menu file
    Args:
        cookbook_root:
        recipe_type:
        recipe_name: name of the recipe
        recipe_label: GUI friendly label of the recipe
    """
    from cgl.core.utils.general import cgl_copy

    # copy the template file to the new file
    template_file = get_blender_menu_template(cookbook_root)
    new_file = get_blender_menu_file(cookbook_root, recipe_type, recipe_name)

    if os.path.exists(new_file):
        print("Blender Menu File already exists: {}".format(new_file))
        return
    # copoy template file to new file
    cgl_copy(template_file, new_file)
    file_list = load_text_file(new_file)
    new_file_list = []
    for line in file_list:
        # look for #PanelTemplate and replace it with the recipe name in camel case
        if "PanelTemplate" in line:
            new_line = line.replace("PanelTemplate", recipe_name)
            new_file_list.append(new_line)
        # look for RECIPE_LABEL and replace it with the recipe label
        elif "RECIPE_LABEL" in line:
            new_line = line.replace("RECIPE_LABEL", recipe_label)
            new_file_list.append(new_line)
        # look for RECIPE_NAME and replace it with the recipe name.
        elif "RECIPE_NAME" in line:
            new_line = line.replace("RECIPE_NAME", recipe_name)
            new_file_list.append(new_line)
        else:
            new_line = line
            new_file_list.append(new_line)

    # go through and replace default values with the receipe name and recipe label
    save_text_lines(new_file_list, new_file)
    print(new_file)



if __name__ == "__main__":
    create_blender_menu_file(r"E:/Alchemy/cgl/config", "menus", "art", "Art")