pipeflowIm.py

import logging

import dearpygui.dearpygui as dpg

from pipeflowData import PipeflowData, p_to_f,f_to_p
from pipeflowMonitor import PipeflowMonitor
from pipeflowControl import PipeflowControl

log = logging.getLogger("main")
data = PipeflowData(log)
monitor = PipeflowMonitor(data)
control = PipeflowControl(data)

data.load_config()

#Start Pipewire monitoring thread
monitor.start_loop()

#Other temporary global values
class Other:
    def __init__(self):
        self.hovered_link = None
        self.editor_size = None

        self.node_unsorted = []
        self.node_groups = [ [] for g in data.config.group_order ]
        self.visited = []
        self.sorted_mode = -1
        self.visit_iteration = 0
        self.next_group = 1
other = Other()

# Pipewire to GUI update functions
def meta_refresh():
    dpg.set_value(data.metadata.sink_button, False)
    dpg.set_value(data.metadata.source_button, False)

    # Find new default nodes
    for node in data.nodes.values():
        if node.im != 0 and node.is_default(data.metadata):
            if node.can_default == 1:
                data.metadata.sink_button = node.default_button
                dpg.set_value(node.default_button, True)
            elif node.can_default == 2:
                data.metadata.source_button = node.default_button
                dpg.set_value(node.default_button, True)
            else:
                log.error("Unexpected default node set "+node.node_label)

def node_refresh(node):
    if node.deleted or node.is_hidden(data.config):
        if node.im != 0:
            dpg.delete_item(node.im)
            node.im = 0
            if node.current_group != -1:
                other.node_groups[node.current_group].remove(node)
            elif node in other.node_unsorted:
                other.node_unsorted.remove(node)
            node.current_group = -1
        return

    # Update node values
    if node.im != 0:
        if node.mute_button != 0:
            dpg.set_value(node.mute_button, node.mute)
        for channel in node.channels:
            channel.percent_volume = f_to_p(channel.chn_volume)
            if channel.im != 0:
                dpg.set_value(channel.im, channel.percent_volume)
        if node.channel_lock and node.lock_button != 0:
            if not all(x.chn_volume == node.channels[0].chn_volume for x in node.channels):
                node.channel_lock = False
                dpg.set_value(node.lock_button, False)
    else:
        add_node(node)
        sort()

def port_refresh(port):
    node = data.nodes[port.node_id]
    if node.im != 0 and port.im == 0:
        for channel in node.channels:
            if port in channel.ports:
                with dpg.node_attribute(parent=node.im, label=port.port_label, attribute_type=dpg.mvNode_Attr_Input if port.is_inport else dpg.mvNode_Attr_Output) as aid:
                    port.im = aid
                    if channel.im == 0 and not channel.placeholder:
                        channel.im = dpg.add_slider_int(label=channel.chn_label, width=150, user_data=node.node_id, max_value=data.config.max_volume, default_value=channel.percent_volume, callback=vol_callback)

                        # Slider tooltip
                        with dpg.tooltip(channel.im):
                            dpg.add_text(tooltip)
                            with dpg.group(horizontal=True):
                                dpg.add_text(channel.chn_label+" =")
                                channel.tooltip_im = dpg.add_text(str(channel.chn_volume))

def link_refresh(link):
    if link.deleted:
        if link.im != 0:
            if data.nodes[link.input_node_pw].im != 0 and data.nodes[link.output_node_pw].im != 0:
                dpg.delete_item(link.im)
            link.im = 0
        return

    # Create new link
    if link.im == 0:
        if link.input_port_pw in data.ports:
            link.input_attribute_im = data.ports[link.input_port_pw].im
        if link.output_port_pw in data.ports:
            link.output_attribute_im = data.ports[link.output_port_pw].im

        if link.input_attribute_im != 0 and link.output_attribute_im != 0:
            link.im = dpg.add_node_link(link.input_attribute_im, link.output_attribute_im, parent="editor")
        #sort()
    if data.config.group_mode == C_GROUP:
        other.sorted_mode = -1
        sort()

# GUI to Pipewire update functions
def mute_callback(sender, toggle, node_id):
    data.nodes[node_id].mute = toggle
    control.update_mute(data.nodes[node_id])

def default_callback(sender, toggle, node_id):
    # Set default node
    if not toggle:
        dpg.set_value(sender, True)
    elif data.nodes[node_id].can_default == 1:
        dpg.set_value(data.metadata.sink_button, False)
        data.metadata.default_sink = data.nodes[node_id].node_name
        data.metadata.sink_button = sender
        control.update_meta(data.metadata, True)
    elif data.nodes[node_id].can_default == 2:
        dpg.set_value(data.metadata.source_button, False)
        data.metadata.default_source = data.nodes[node_id].node_name
        data.metadata.source_button = sender
        control.update_meta(data.metadata, False)

def lock_callback(sender, toggle, node_id):
    # Lock volume channels together
    changed = False
    data.nodes[node_id].channel_lock = toggle
    if toggle and len(data.nodes[node_id].channels) > 1:
        value = data.nodes[node_id].channels[0].percent_volume
        for channel in data.nodes[node_id].channels:
            if channel.im != 0 and channel.percent_volume != value:
                channel.chn_volume = p_to_f(value)
                channel.percent_volume = value
                dpg.set_value(channel.im, value)
                changed = True
        if changed:
            control.update_volume(node)

def vol_callback(sender, value, node_id):
    # Update volume
    changed = False
    lock = data.nodes[node_id].channel_lock
    for channel in data.nodes[node_id].channels:
        if channel.im == sender:
            if channel.percent_volume != value:
                channel.chn_volume = p_to_f(value)
                channel.percent_volume = value
                changed = True
        elif lock:
            if channel.percent_volume != value:
                channel.chn_volume = p_to_f(value)
                channel.percent_volume = value
                dpg.set_value(channel.im, value)
                changed = True
    if changed:
        control.update_volume(node)


# callback runs when user attempts to connect attributes
def link_callback(sender, app_data):
    # app_data -> (link_id1, link_id2)
    inport = None
    outport = None

    # Find selected ports
    data.delete_lock += 1
    for port in data.ports.values():
        if port.im == app_data[0] or port.im == app_data[1]:
            if port.is_inport:
                inport = port
            else:
                outport = port
    data.delete_lock -= 1
    if inport and outport:
        control.add_link(inport, outport)

# callback runs when user attempts to disconnect attributes
def delink_callback(sender, app_data):
    # app_data -> link_id
    data.delete_lock += 1
    for link in data.links.values():
        if link.im == app_data:
            control.remove_link(link)
    data.delete_lock -= 1

# Menu options callbacks
def quit_callback(sender):
    dpg.stop_dearpygui()

def max_volume_callback(sender, app_data):
    data.config.max_volume = app_data
    data.save_config()
    data.delete_lock += 1
    for node in data.nodes.values():
        for channel in node.channels:
            if channel.im != 0:
                dpg.configure_item(channel.im, max_value=app_data)
    data.delete_lock -= 1

def show_hidden_callback(sender, app_data):
    data.config.show_hidden = app_data
    data.save_config()
    other.sorted_mode = -1
    sort()

def add_hidden_callback(sender, app_data, user_data):
    if app_data == True or app_data == False:
        data.config.hide_names.append(user_data)
    else:
        data.config.hide_names.append(app_data)
    data.save_config()
    dpg.set_value("hide_names_input", "")
    dpg.configure_item("hide_names_config", items=data.config.hide_names)
    other.sorted_mode = -1
    sort()

def remove_hidden_callback(sender):
    data.config.hide_names.remove(dpg.get_value("hide_names_config"))
    data.save_config()
    dpg.configure_item("hide_names_config", items=data.config.hide_names)
    other.sorted_mode = -1
    sort()

def hide_button_callback(sender, app_data):
    data.config.hide_button = app_data
    data.delete_lock += 1
    for node in data.nodes.values():
        if node.im != 0 and node.hide_button != 0:
            if app_data:
                dpg.show_item(node.hide_button)
            else:
                dpg.hide_item(node.hide_button)
    data.delete_lock -= 1

def sort_names_callback(sender, app_data):
    data.config.sort_names = app_data
    data.save_config()
    if not app_data:
        other.sorted_mode = -1
    sort()

def sort_moved_callback(sender, app_data):
    data.config.sort_moved = app_data
    data.save_config()
    sort()

def group_vertical_callback(sender, app_data):
    data.config.group_vertical = app_data
    data.save_config()
    sort()

def group_mode_callback(sender, app_data):
    data.config.group_mode = data.config.group_mode_names.index(app_data)
    data.save_config()
    other.sorted_mode = -1
    sort()

# GUI mouse functions
def link_hover_callback(sender, app_data):
    global hovered_link
    if hovered_link != app_data:
        hovered_link = app_data
        #dpg.set_value("message", "hover "+str(app_data))

def window_left_click_callback(sender, app_data):
    #dpg.set_value("message", "left "+str(hovered_link))
    pass

def window_right_click_callback(sender, app_data):
    #dpg.set_value("message", "right "+str(hovered_link))
    pass

def window_startup_callback(sender, app_data):
    dpg.configure_item("startup", show=False)
    global editor_size
    editor_size = [dpg.get_viewport_width(), dpg.get_viewport_height()]
    print(data.metadata.default_sink, data.metadata.default_source)
    sort()

def node_label(node):
    return node.node_label

def node_type(node):
    return data.config.group_order.index(node.node_type)

def group_label(group):
    if len(group) > 0:
        return group[0].node_label
    else:
        return ""

C_GROUP = 4

# Sort all nodes
def sort():
    data.delete_lock += 1

    # Resort all
    if other.sorted_mode != data.config.group_mode:
        other.node_unsorted = list(data.nodes.values())
        other.node_groups = [ [] for g in data.config.group_order ]
        other.visited = []
        other.next_group = 1

    # Sort nodes into groups
    for node in other.node_unsorted:
        if node.deleted or node.is_hidden(data.config):
            if node.im != 0:
                dpg.delete_item(node.im)
                node.im = 0
                if node.current_group != -1 and node in other.node_groups[node.current_group]:
                    other.node_groups[node.current_group].remove(node)
                elif node in other.node_unsorted:
                    other.node_unsorted.remove(node)
                node.current_group = -1
            continue
        elif node.im == 0:
            add_node(node)
        if node.im != 0:
            if data.config.group_mode == 0:
                # No sorting
                other.node_groups[0].append(node)
                node.current_group = 0
            elif data.config.group_mode == 1:
                group_value(node, node.node_type)
            elif data.config.group_mode == 2:
                group_value(node, node.node_api)
            elif data.config.group_mode == 3:
                group_value(node, node.node_label)
            elif data.config.group_mode == C_GROUP:
                # Sort by connections
                if other.sorted_mode == -1 and node not in other.visited:
                    connected = visit_connections(node)
                    if len(connected) > 1:
                        node.current_group = other.next_group
                        if other.next_group > len(data.config.group_order):
                            data.config.group_order.append("Connections "+str(other.next_group))
                            other.node_groups.append([])
                        other.node_groups[other.next_group] = connected
                        other.next_group += 1
                    else:
                        node.current_group = 0
                        other.node_groups[0].append(node)
                elif node not in other.visited:
                    linked = [ data.nodes[id] for id in node.linked_ids() ]
                    if len(linked) > 0:
                        node.current_group = linked[0].current_group
                        other.node_groups.append(node)
                    else:
                        node.current_group = 0
                        other.node_groups[0].append(node)
    # Finished sorting pass
    other.node_unsorted = []
    other.sorted_mode = data.config.group_mode

    # Prepare for GUI pass
    margins = data.config.margins
    padding = data.config.padding
    group_padding = data.config.group_padding

    pos = [margins, margins]
    size = [0,0]
    height = margins
    group_height = margins
    group_margins = margins
    v = [1,0] if data.config.group_vertical else [0,1]

    # Sort groups by name
    if data.config.group_mode == 3:
        other.node_groups.sort(key=group_label)

    # Place nodes by group and order
    for group in other.node_groups:
        if data.config.sort_names:
            group.sort(key=node_label)
        elif data.config.group_mode == C_GROUP:
            group.sort(key=node_type)
        #print([ n.node_label for n in group ])
        for node in group:
            if node.im != 0 and node.pos != [0,0] and node.pos != dpg.get_item_pos(node.im):
                node.moved = True
            if node.im != 0 and (not node.moved or data.config.sort_moved):
                size = dpg.get_item_rect_size(node.im)
                node.size = size
                height = max(height, pos[v[1]]+size[v[1]])
                group_height = max(group_height, pos[v[0]]+size[v[0]])

                #Next line
                if pos[v[0]] + size[v[0]] >= editor_size[v[0]]:
                    pos[v[0]] = group_margins
                    pos[v[1]] = height + padding
                    height = pos[v[1]] + size[v[1]]

                dpg.set_item_pos(node.im, pos)
                pos[v[0]] += size[v[0]] + padding
                node.pos = dpg.get_item_pos(node.im)
                node.moved = False
                #print(node, size)
        # Group to next line
        if len(group) > 0:
            pos[v[0]] = group_margins
            pos[v[1]] = height + padding + group_padding
            height = pos[v[1]]

            # Next row of groups
            if pos[v[1]] + size[v[1]] >= editor_size[v[1]]:
                group_margins = group_height + padding + group_padding
                pos[v[0]] = group_margins
                pos[v[1]] = margins
                height = pos[v[1]]
                group_height = pos[v[0]]
    data.delete_lock -= 1

def group_value(node, value):
    if value not in data.config.group_order:
        data.config.group_order.append(value)
        other.node_groups.append([])
    node.current_group = data.config.group_order.index(value)
    other.node_groups[node.current_group].append(node)

def visit_connections(node):
    # Group nodes by connection from scratch
    group = [node]
    linked = [ data.nodes[id] for id in node.linked_ids() if data.nodes[id] not in other.visited ]
    other.visited += linked
    group += linked

    for n in linked:
        n.current_group = other.next_group
        group += visit_connections(n)
    return list(set(group))

def add_node(node):
    with dpg.node(label=node.node_label, parent="editor") as nid:
        node.im = nid
        node.current_group = -1
        node.pos = [0,0]
        if node not in other.node_unsorted:
            other.node_unsorted.append(node)

        tool_id = 0
        tooltip = str(node.node_id) + ":" + node.node_name + ":" + node.node_type

        # Node controls
        with dpg.node_attribute(label="", attribute_type=dpg.mvNode_Attr_Static):
            with dpg.group(horizontal=True) as tid:
                tool_id = tid
                node.mute_button = dpg.add_selectable(label="Mute", width=28, user_data=node.node_id, default_value=node.mute, callback=mute_callback)
                if len(node.channels) > 1:
                    node.lock_button = dpg.add_selectable(label="Lock", width=28, user_data=node.node_id, default_value=node.channel_lock, callback=lock_callback)

                # Default node selector
                if node.can_default != 0:
                    d = node.is_default(data.metadata)
                    node.default_button = dpg.add_selectable(label="Default", width=50, user_data=node.node_id, default_value=d, callback=default_callback)
                    if d and node.can_default == 1:
                        data.metadata.sink_button = node.default_button
                    elif d and node.can_default == 2:
                        data.metadata.source_button = node.default_button

                node.hide_button = dpg.add_selectable(label="Hide", width=28, user_data=node.node_label, callback=add_hidden_callback, show=data.config.hide_button)

        # Volume controls and connections
        for channel in node.channels:
            for port in channel.ports:
                with dpg.node_attribute(label=port.port_label, attribute_type=dpg.mvNode_Attr_Input if port.is_inport else dpg.mvNode_Attr_Output) as aid:
                    port.im = aid
                    if channel.im == 0 and not channel.placeholder:
                        channel.im = dpg.add_slider_int(label=channel.chn_label, width=150, user_data=node.node_id, max_value=data.config.max_volume, default_value=channel.percent_volume, callback=vol_callback)

                        # Slider tooltip
                        with dpg.tooltip(channel.im):
                            dpg.add_text(tooltip)
                            #for inport2 in channel.inports:
                            #    dpg.add_text(str(inport2.port_id)+":"+inport2.port_label)
                            with dpg.group(horizontal=True):
                                dpg.add_text(channel.chn_label+" =")
                                channel.tooltip_im = dpg.add_text(str(channel.chn_volume))
                    # Mark links
                    for link in port.links:
                        if port.is_inport:
                            link.input_attribute_im = aid
                        else:
                            link.output_attribute_im = aid

            # If missing port
            if channel.im == 0 and not channel.placeholder:
                with dpg.node_attribute(label="", attribute_type=dpg.mvNode_Attr_Static) as aid:
                    channel.im = dpg.add_slider_int(label=channel.chn_label, width=150, max_value=data.config.max_volume, default_value=channel.percent_volume)

        #Tooltip
        with dpg.tooltip(tool_id):
            dpg.add_text(tooltip)

#Start DearPYGUI window
dpg.create_context()
dpg.create_viewport(title='PipeflowIm', width=1920, height=1080)

# Window contents
with dpg.window(tag="Nodes", width=1920, height=1080):
    with dpg.menu_bar():
        dpg.add_text("Pipeflow")
        with dpg.menu(label="Options"):
            dpg.add_text("Max Overflow Volume:")
            dpg.add_slider_int(min_value=100, max_value=200, default_value=data.config.max_volume, callback=max_volume_callback)
            dpg.add_menu_item(label="Quit", callback=quit_callback)

        with dpg.menu(label="Hidden"):
            dpg.add_listbox(items=data.config.hide_names, tag="hide_names_config")
            dpg.add_menu_item(label="Remove selected from list", callback=remove_hidden_callback)
            dpg.add_text("Add name to list:")
            dpg.add_input_text(tag="hide_names_input", on_enter=True, callback=add_hidden_callback)
            dpg.add_checkbox(label="Show Hidden", default_value=data.config.show_hidden, callback=show_hidden_callback)
            dpg.add_checkbox(label="Hide Node Button", default_value=data.config.hide_button, callback=hide_button_callback)

        with dpg.menu(label="Sorting"):
            current_mode = data.config.group_mode_names[data.config.group_mode]
            dpg.add_listbox(items=data.config.group_mode_names, tag="group_mode_config", num_items=len(data.config.group_mode_names), default_value=current_mode, callback=group_mode_callback)
            dpg.add_checkbox(label="Group Vertically", default_value=data.config.group_vertical, callback=group_vertical_callback)
            dpg.add_checkbox(label="Sort by Name", default_value=data.config.sort_names, callback=sort_names_callback)
            dpg.add_checkbox(label="Sort Moved Nodes", default_value=data.config.sort_moved, callback=sort_moved_callback)

    dpg.add_text("startup", tag="startup")

    with dpg.node_editor(tag="editor", callback=link_callback, delink_callback=delink_callback):
        data.delete_lock += 1
        other.node_unsorted = list(data.nodes.values())
        for node in other.node_unsorted:
            if not node.deleted and not node.is_hidden(data.config):
                add_node(node)

        for link in data.links.values():
            if link.input_attribute_im != 0 and link.output_attribute_im != 0:
                link.im = dpg.add_node_link(link.input_attribute_im, link.output_attribute_im)

# Pipewire to GUI update functions
data.meta_refresh = meta_refresh
data.node_refresh = node_refresh
data.port_refresh = port_refresh
data.link_refresh = link_refresh
data.delete_lock -= 1

# Global Registries
with dpg.item_handler_registry(tag="startup_handler"):
    dpg.add_item_visible_handler(callback=window_startup_callback)

dpg.bind_item_handler_registry("startup", "startup_handler")

with dpg.handler_registry():
    dpg.add_mouse_click_handler(button=0, callback=window_left_click_callback)
    dpg.add_mouse_click_handler(button=1, callback=window_right_click_callback)

# Item specific Registries
with dpg.item_handler_registry(tag="link_handler"):
    dpg.add_item_hover_handler(callback=link_hover_callback)
    #dpg.add_item_clicked_handler(callback=window_left_click_callback)

dpg.setup_dearpygui()
dpg.show_viewport()
dpg.set_primary_window("Nodes", True)
dpg.start_dearpygui()
dpg.destroy_context()

monitor.stop_loop()