mantis/timers.py

from .utilities.utilities import (prRed, prGreen, prPurple, prWhite,
                              prOrange,
                              wrapRed, wrapGreen, wrapPurple, wrapWhite,
                              wrapOrange,)

# the first step is to get selection syncing working
import bpy
from bpy import context
from .base_definitions import get_signature_from_edited_tree 

from bpy.types import Bone, PoseBone
# just to prevent confusing with Python object:
from bpy.types import Object as bpy_object

SELECTION_POLL_RATE = 0.01
ENABLED = True
cached_selection_state = {}

import bpy

# The following node types represent objects that can be selected.
WATCH_FOR_SELECTION = [ 'xFormBoneNode', 'xFormArmatureNode',
        'xFormGeometryObject', 'xFormObjectInstance', 'xFormCurvePin',
        'xFormGetBone', 'InputExistingGeometryObject']


def get_signature_from_space(node, space):
    sig_path=[None,]
    for item in space.path[:-1]:
        sig_path.append(item.node_tree.nodes.active.name)
    return tuple(sig_path+[node.name])

def get_visible_space_data(space_types={'NODE_EDITOR'}):
    visible_spaces = []
    for wm in bpy.data.window_managers:
        for window in wm.windows:
            for area in window.screen.areas:
                if area.type in space_types:
                    if area.spaces.active:
                        visible_spaces.append(area.spaces.active)
                        
    return visible_spaces

# Example usage: Get all active 3D Viewport space_data objects
spaces = get_visible_space_data('VIEW_3D')

for space in spaces:
    print(f"Found 3D Viewport: shading mode = {space.shading.type}")

# TODO: now that I have this working...
#  - Selection State should be tracked and handled on a per-object basis
#     so Mantis should update selection state one item at a time
#  - finally, I want to extend this selection sync to show active constraints and modifiers
#     and to link up with viewport gizmo tools.
#  - Serialize this so that it sticks around when saving/loading file
# Eventually:
#  - sync scene/object selection to node graph. I have the structure in place
#     but I still have to write the selection tracking code.
# Potential small BUG?
#  - I am not ensuring the base/root tree is the same for the space and the nodes
#  - because I straight up do not store that in the selection_sync dicts
#  - easy to fix, will do it when clearing TODO's here.

def timer_update_selection_sync():
    if not ENABLED: return None
    root_tree = None
    tree_path = None
    parsed_tree = None
    spaces = get_visible_space_data()
    if not spaces:
        return SELECTION_POLL_RATE

    selection_state_start = cached_selection_state.copy()
    selection_state = cached_selection_state.copy()
    current_tree_selected_total = 0

    # we can't get UI context in this function so we have to checc all of them
    #maybe the tree itself can load the timer when it is opened in the node editor?
    for space in spaces:
        # if we are in the node editor, manage node selection
        if space.type == "NODE_EDITOR":
            root_tree = space.path[0].node_tree
            parsed_tree = root_tree.parsed_tree
            tree_path = [path_item.node_tree for path_item in space.path]
            if root_tree is None:
                return SELECTION_POLL_RATE
            if root_tree.bl_idname != 'MantisTree':
                return SELECTION_POLL_RATE
            active_ui_signature = (get_signature_from_space(tree_path[-1].nodes.active, space))
            for n in tree_path[-1].nodes:
                if n.bl_idname not in WATCH_FOR_SELECTION: continue
                selection_state[ui_signature := get_signature_from_space(n, space)] = n.select
                current_tree_selected_total += int(n.select)
    
    if parsed_tree is None:
        return SELECTION_POLL_RATE
    cached_selection_state.update(selection_state)
    # We only fire the update if things have changed.
    if selection_state != selection_state_start:
        
        from bpy import context
        view_layer = context.view_layer
        deselect = not bool(current_tree_selected_total)
        try:
            update_scene_selection_from_node_graph_selection_sync(
                active_ui_signature, view_layer,
                selection_state, deselect)
        except Exception as e:
            prRed (e)
            return SELECTION_POLL_RATE
    return SELECTION_POLL_RATE

def update_scene_selection_from_node_graph_selection_sync(
        active_ui_signature, view_layer,
        selection_state, deselect ):
    from .base_definitions import ( selection_sync_node_to_object,
                                    selection_sync_object_to_node, )
    prWhite("Updating Scene Selection from Node Graph Selection")
    deselect_do_once = []
    for ui_signature, selected in selection_state.items():
        this_one_is_active = False
        if ui_signature == active_ui_signature: this_one_is_active = True
        for object_key in selection_sync_node_to_object.get(ui_signature, []):
            id_data = bpy.data.objects.get(object_key[0])
            if object_key[1]: # we have a sub_value, it's a bone
                if deselect and object_key[0] not in deselect_do_once:
                    for pb in id_data.pose.bones:
                        pb.select = False
                    deselect_do_once.append(object_key[0])
                else:
                    ob = id_data.pose.bones[object_key[1]]
                    ob.select = selected
                    if this_one_is_active: # set the active bone
                        id_data.data.bones.active = ob.bone
                    # now do its parent object...
                    if selected:
                        id_data.select_set(True, view_layer=view_layer)
                        if this_one_is_active:
                            view_layer.objects.active = id_data
            else: # or the sub_value is None, this is an object
                ob = id_data
                if deselect: selected = False
                ob.select_set(selected, view_layer=view_layer)
                if this_one_is_active and not deselect:
                    view_layer.objects.active = ob