API tools faq
paste
Advertisement
yayopoint

jack-keyboard-manager.py

yayopoint
Aug 18th, 2012
400
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 28.78 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/python3
  2. # -*- coding: utf-8 -*-
  3.  
  4. ####################################
  5. ###           Módulos            ###
  6. ####################################
  7. import dbus
  8. from gi.repository import Gtk
  9. from gi.repository import Gdk
  10. from dbus.mainloop.glib import DBusGMainLoop
  11.  
  12.  
  13. # Hay que hacer este llamado antes de definir el bus
  14. dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
  15.  
  16. ####################################
  17. ###             Bus              ###
  18. ####################################
  19. bus = dbus.SessionBus()
  20. jack_control_obj = bus.get_object("org.jackaudio.service", "/org/jackaudio/Controller")
  21. jack_control_ifa = dbus.Interface(jack_control_obj, "org.jackaudio.JackPatchbay")
  22.  
  23. graph = jack_control_ifa.GetGraph(0)
  24.  
  25. ####################################
  26. ###          Funciones           ###
  27. ####################################
  28. def match_func_tree(model, iter, data):
  29.   column, key = data # data es una tupla que contiene número de columna, clave (key)
  30.   value = model.get_value(iter, column)
  31.   return value == key
  32.  
  33. def search_tree(model, iter, func, data, include_children = False):
  34.   while iter:
  35.     if func(model, iter, data):
  36.       return iter
  37.     if include_children:
  38.       result = search(model, model.iter_children(iter), func, data)
  39.       if result: return result
  40.     iter = model.iter_next(iter)
  41.   return None
  42.  
  43. def get_tree(model, iter, recursive = False):
  44.   store = []
  45.   while iter:
  46.     store.append(iter)
  47.     if recursive:
  48.       store.append(get_tree(model, model.iter_children(iter), recursive=True))
  49.     iter = model.iter_next(iter)
  50.   return store
  51.  
  52. def get_tree_len(model, iter, recursive = False):
  53.   i = 0
  54.   while iter:
  55.     i += 1
  56.     if recursive:
  57.       i += get_tree_len(model,  model.iter_children(iter), recursive=True)
  58.     iter = model.iter_next(iter)
  59.   return i
  60.  
  61. def isInputOrOutput(JackPortFlags):
  62.   if((JackPortFlags & 0x1) != 0):
  63.     return "input"
  64.   elif((JackPortFlags & 0x2) != 0):
  65.     return "output"
  66.   elif ((JackPortFlags & 0x1) != 0) & ((JackPortFlags & 0x2) != 0):
  67.     print("Error: Un puerto no puede ser de entrada y salida a la vez")
  68.  
  69. def getID(search, array, id_index):
  70.   i = 0
  71.   exist = False
  72.   for item in array:
  73.     if item[id_index] == search:
  74.       exist = True
  75.       break
  76.     i += 1
  77.   if exist:
  78.     return i
  79.   else:
  80.     return None
  81.  
  82. ####################################
  83. ###          Variables           ###
  84. ###          Globales            ###
  85. ####################################
  86.  
  87. ### 0: Audio Input
  88. ### 1: Audio Output
  89. ### 2: Midi Input
  90. ### 3: Midi Output
  91. categorized_ports = [[], [], [], []]
  92. for client in graph[1]:
  93.   for port in client[2]:
  94.     # Una explicación breve, esto es para ahorrar un if
  95.     category = int(isInputOrOutput(port[2]) == "output") + int(port[3] == 1) * 2
  96.     client_exist = False
  97.     a_client_id = 0
  98.     for cclient in categorized_ports[category]:
  99.       if cclient[0] == client[0]:
  100.         client_exist = True
  101.         break
  102.       a_client_id += 1
  103.     if not client_exist:
  104.       categorized_ports[category].append([client[0], client[1], []])
  105.       client_id = len(categorized_ports[category]) -1
  106.     categorized_ports[category][a_client_id][2].append([port[0], port[1], port[2], port[3]])
  107.  
  108. # Base de datos auxiliar de Clientes y Puertos
  109. # clients contiene:
  110. #  [client_id, client_name, client_instances, client_active]
  111. # ports contiene:
  112. #  [client_id, port_id, port_name, port_flags, port_type, port_selected, port_active]
  113. clients = []
  114. ports = []
  115. for client in graph[1]:
  116.   clients.append([client[0], client[1], [], True])
  117.   for port in client[2]:
  118.     ports.append([client[0], port[0], port[1], port[2], port[3], False, True])
  119.  
  120. # [client1_id, client1_name, port1_id, port1_name, client2_id, client2_name, port2_id, port2_name, connection_id]
  121. connections = graph[2]
  122. # [keyboard_id, keyboard_name, [effect_id, active]]
  123. effects = []
  124.  
  125. ####################################
  126. ###             GUI              ###
  127. ####################################
  128. class MyWindow(Gtk.Window):
  129.   def __init__(self):
  130.     Gtk.Window.__init__(self, title="Jack Keyboard Manager")
  131.     self.set_default_size(700, 500)
  132.  
  133.     # Estos dos Arrays contendrán los treestores y los treeviews
  134.     self.TreeStores = [Gtk.TreeStore(int, str), # 0: Audio Input
  135.                        Gtk.TreeStore(int, str), # 1: Audio Output
  136.                        Gtk.TreeStore(int, str), # 2: MIDI Input
  137.                        Gtk.TreeStore(int, str), # 3: MIDI Output
  138.                        Gtk.TreeStore(int, str), # 4: Audio Input Selected
  139.                        Gtk.TreeStore(int, str), # 5: Audio Output Selected
  140.                        Gtk.TreeStore(int, str), # 6: MIDI Input Selected
  141.                        Gtk.TreeStore(int, str)] # 7: MIDI Output Selected
  142.     self.TreeViews = [Gtk.TreeView(self.TreeStores[0]), # 0: Audio Input
  143.                       Gtk.TreeView(self.TreeStores[1]), # 1: Audio Output
  144.                       Gtk.TreeView(self.TreeStores[2]), # 2: MIDI Input
  145.                       Gtk.TreeView(self.TreeStores[3]), # 3: MIDI Output
  146.                       Gtk.TreeView(self.TreeStores[4]), # 4: Audio Input Sel
  147.                       Gtk.TreeView(self.TreeStores[5]), # 5: Audio Output Sel
  148.                       Gtk.TreeView(self.TreeStores[6]), # 6: MIDI Input Sel
  149.                       Gtk.TreeView(self.TreeStores[7])] # 7: MIDI Output Sel
  150.  
  151.     # Números y letras en orden de un teclado QUERTY español
  152.     numbers = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
  153.     letters1 = ["q", "w", "e", "r", "t", "y", "u", "i", "o", "p"]
  154.     letters2 = ["a", "s", "d", "f", "g", "h", "j", "k", "l"]
  155.     letters3 = ["z", "x", "c", "v", "b", "n", "m"]
  156.     self.keymap = [letters3, None, letters1+letters2, numbers]
  157.     k_numbers = [49,50,51,52,53,54,55,56,57,48]
  158.     k_letters1 = [113,119,101,114,116,121,117,105,111,112]
  159.     k_letters2 = [97,115,100,102,103,104,106,107,108]
  160.     k_letters3 = [122,120,99,118,98,110,109]
  161.     self.keyvals = [k_letters3, None, k_letters1+k_letters2, k_numbers]
  162.  
  163.     # Teclado seleccionado en la pestaña Rutas
  164.     # [client_id, client_name, port_id, port_name]
  165.     self.keyboard_selected = None
  166.  
  167.     # Bloquear los botones de sintetizador
  168.     # Para que no se activen automáticamente
  169.     self.lock_synth = False
  170.  
  171.     for num in range(8):
  172.       cellRenderer = Gtk.CellRendererText()
  173.       column0 = Gtk.TreeViewColumn("ID", cellRenderer, text=0)
  174.       column1 = Gtk.TreeViewColumn("Puertos", cellRenderer, text=1)
  175.       self.TreeViews[num].append_column(column0)
  176.       self.TreeViews[num].append_column(column1)
  177.  
  178.     # Caja Principal
  179.     main_box = Gtk.VBox(False, 3)
  180.  
  181.     # Toda la interfaz se organiza en tres pestañas
  182.     # - La primera para seleccionar dispositivos
  183.     # - La segunda para definir las rutas de Jack
  184.     # - La tercera para configuraciones avanzadas
  185.     notebook = Gtk.Notebook()
  186.     notebook.set_tab_pos(2)
  187.  
  188.     ### Primera Pestaña: Selección de dispositivos ###
  189.     box = Gtk.VBox(False, 3)
  190.  
  191.     title = "Seleccione los Teclados"
  192.     frame = Gtk.Frame()
  193.     frame.set_label(title)
  194.     table = Gtk.Table(4,3,True)
  195.     # Modelo teclados
  196.     # Este modelo contiene los puertos para seleccionar los teclados
  197.     # Puertos Midi de Salida
  198.     swT1 = Gtk.ScrolledWindow()
  199.     self.__create_model(3)
  200.     swT1.add(self.TreeViews[3])
  201.     buttonTADD = Gtk.Button("Agregar ->")
  202.     buttonTDEL = Gtk.Button("<- Quitar")
  203.     swT2 = Gtk.ScrolledWindow()
  204.     # Modelo de Teclados Seleccionados
  205.     swT2.add(self.TreeViews[7])
  206.     table.attach(swT1, 0, 1, 0, 4)
  207.     table.attach(buttonTADD, 1, 2, 1, 2)
  208.     table.attach(buttonTDEL, 1, 2, 2, 3)
  209.     table.attach(swT2, 2, 3, 0, 4)
  210.     frame.add(table)
  211.     box.add(frame)
  212.  
  213.     # Conexión de los botones para teclados
  214.     buttonTADD.connect("clicked", self.__sel_item, self.TreeStores[3], self.TreeViews[3], self.TreeStores[7])
  215.     buttonTDEL.connect("clicked", self.__sel_item, self.TreeStores[7], self.TreeViews[7], self.TreeStores[3])
  216.  
  217.     title = "Seleccione los Sintetizadores"
  218.     frame = Gtk.Frame()
  219.     frame.set_label(title)
  220.     table = Gtk.Table(4,3,True)
  221.     # Modelo de los sintetizadores
  222.     # Este modelo muestra los puertos para seleccionar sintetizadores
  223.     # Puertos Midi de entrada
  224.     swS1 = Gtk.ScrolledWindow()
  225.     self.__create_model(2)
  226.     swS1.add(self.TreeViews[2])
  227.     buttonSADD = Gtk.Button("Agregar ->")
  228.     buttonSDEL = Gtk.Button("<- Quitar")
  229.     swS2 = Gtk.ScrolledWindow()
  230.     # Modelo de Sintetizadores seleccionados
  231.     swS2.add(self.TreeViews[6])
  232.     table.attach(swS1, 0, 1, 0, 4)
  233.     table.attach(buttonSADD, 1, 2, 1, 2)
  234.     table.attach(buttonSDEL, 1, 2, 2, 3)
  235.     table.attach(swS2, 2, 3, 0, 4)
  236.     frame.add(table)
  237.     box.add(frame)
  238.  
  239.     # Conexión de los botones para sintetizadores
  240.     buttonSADD.connect("clicked", self.__sel_item, self.TreeStores[2], self.TreeViews[2], self.TreeStores[6])
  241.     buttonSDEL.connect("clicked", self.__sel_item, self.TreeStores[6], self.TreeViews[6], self.TreeStores[2])
  242.  
  243.     title = "Seleccione los Efectos"
  244.     frame = Gtk.Frame()
  245.     frame.set_label(title)
  246.     table = Gtk.Table(4,3,True)
  247.     swE1 = Gtk.ScrolledWindow()
  248.     self.__create_model(0)
  249.     swE1.add(self.TreeViews[0])
  250.     buttonEADD = Gtk.Button("Agregar ->")
  251.     buttonEDEL = Gtk.Button("<- Quitar")
  252.     swE2 = Gtk.ScrolledWindow()
  253.     swE2.add(self.TreeViews[4])
  254.     table.attach(swE1, 0, 1, 0, 4)
  255.     table.attach(buttonEADD, 1, 2, 1, 2)
  256.     table.attach(buttonEDEL, 1, 2, 2, 3)
  257.     table.attach(swE2, 2, 3, 0, 4)
  258.     frame.add(table)
  259.     box.add(frame)
  260.  
  261.     # Conexión de los botones para sintetizadores
  262.     buttonEADD.connect("clicked", self.__sel_item, self.TreeStores[0], self.TreeViews[0], self.TreeStores[4], 2)
  263.     buttonEDEL.connect("clicked", self.__sel_item, self.TreeStores[4], self.TreeViews[4], self.TreeStores[0], 2)
  264.  
  265.     self.TreeViews[0].get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
  266.  
  267.     txt = "Puertos"
  268.     label = Gtk.Label(txt)
  269.     notebook.append_page(box, label)
  270.  
  271.     ### Segunda Pestaña: Selección de salidas ###
  272.     box = Gtk.VBox(False, 3)
  273.  
  274.     txt = "Salidas"
  275.     label = Gtk.Label(txt)
  276.     notebook.append_page(box, label)
  277.  
  278.     ### Tercera Pestaña: Rutas Jack ###
  279.     box = Gtk.VBox(False, 3)
  280.  
  281.     self.RoutesButtons = [[], None, [], []]
  282.     self.RoutesLabels = [[], None, [], []]
  283.  
  284.     title = "Teclados"
  285.     frame = Gtk.Frame()
  286.     frame.set_label(title)
  287.  
  288.     box1 = Gtk.HBox(False, 3)
  289.     i = 0
  290.     for number in numbers:
  291.       self.RoutesLabels[3].append(Gtk.Label(number))
  292.       self.RoutesLabels[3][i].set_justify(2)
  293.       self.RoutesButtons[3].append(Gtk.ToggleButton())
  294.       self.RoutesButtons[3][i].add(self.RoutesLabels[3][i])
  295.       self.RoutesButtons[3][i].set_size_request(60,60)
  296.       self.RoutesButtons[3][i].connect("clicked", self.__keyboard, i)
  297.       box1.pack_start(self.RoutesButtons[3][i], False, False, 0)
  298.       i += 1
  299.     frame.add(box1)
  300.     box.pack_start(frame, False, False, 0)
  301.  
  302.     title = "Sintetizadores"
  303.     frame = Gtk.Frame()
  304.     frame.set_label(title)
  305.  
  306.     box1 = Gtk.VBox(False, 3)
  307.     # Primera Línea
  308.     box2 = Gtk.HBox(False, 3)
  309.     i = 0
  310.     for letter in letters1:
  311.       self.RoutesLabels[2].append(Gtk.Label(letter))
  312.       self.RoutesLabels[2][i].set_justify(2)
  313.       self.RoutesButtons[2].append(Gtk.ToggleButton())
  314.       self.RoutesButtons[2][i].add(self.RoutesLabels[2][i])
  315.       self.RoutesButtons[2][i].set_size_request(60,60)
  316.       self.RoutesButtons[2][i].connect("clicked", self.__connect_synth, i)
  317.       box2.pack_start(self.RoutesButtons[2][i], False, False, 0)
  318.       i += 1
  319.     box1.pack_start(box2, False, False, 0)
  320.     # Segunda Línea
  321.     box2 = Gtk.HBox(False, 3)
  322.     for letter in letters2:
  323.       self.RoutesLabels[2].append(Gtk.Label(letter))
  324.       self.RoutesLabels[2][i].set_justify(2)
  325.       self.RoutesButtons[2].append(Gtk.ToggleButton())
  326.       self.RoutesButtons[2][i].add(self.RoutesLabels[2][i])
  327.       self.RoutesButtons[2][i].set_size_request(60,60)
  328.       self.RoutesButtons[2][i].connect("clicked", self.__connect_synth, i)
  329.       box2.pack_start(self.RoutesButtons[2][i], False, False, 0)
  330.       i += 1
  331.     box1.pack_start(box2, False, False, 0)
  332.     frame.add(box1)
  333.     box.pack_start(frame, False, False, 0)
  334.  
  335.     title = "Efectos"
  336.     frame = Gtk.Frame()
  337.     frame.set_label(title)
  338.  
  339.     box1 = Gtk.HBox(False, 3)
  340.     i = 0
  341.     for letter in letters3:
  342.       self.RoutesLabels[0].append(Gtk.Label(letter))
  343.       self.RoutesLabels[0][i].set_justify(2)
  344.       self.RoutesButtons[0].append(Gtk.ToggleButton())
  345.       self.RoutesButtons[0][i].add(self.RoutesLabels[0][i])
  346.       self.RoutesButtons[0][i].set_size_request(60,60)
  347.       box1.pack_start(self.RoutesButtons[0][i], False, False, 0)
  348.       i += 1
  349.     frame.add(box1)
  350.     box.pack_start(frame, False, False, 0)
  351.  
  352.     box1 = Gtk.HBox(False, 3)
  353.     self.multiple_synth = Gtk.CheckButton("Múltiples Sintetizadores")
  354.     box1.add(self.multiple_synth)
  355.     box.pack_start(box1, False, False, 0)
  356.  
  357.     self.connect("key-press-event", self.keypress)
  358.  
  359.     txt = "Rutas"
  360.     label = Gtk.Label(txt)
  361.     notebook.append_page(box, label)
  362.  
  363.     ### Cuarta Pestaña: Presets ###
  364.     box = Gtk.VBox(False, 3)
  365.  
  366.     txt = "Presets"
  367.     label = Gtk.Label(txt)
  368.     notebook.append_page(box, label)
  369.     main_box.pack_start(notebook, True, True, 0)
  370.     self.add(main_box)
  371.  
  372.     # Añadir o quitar clientes cuando aparecen o desaparaecent
  373.     jack_control_ifa.connect_to_signal("ClientAppeared", self.__add_client)
  374.     jack_control_ifa.connect_to_signal("PortAppeared", self.__add_port)
  375.     jack_control_ifa.connect_to_signal("ClientDisappeared", self.__del_client)
  376.     jack_control_ifa.connect_to_signal("PortDisappeared", self.__del_port)
  377.     # Añadir conecciones cuando se producen
  378.     jack_control_ifa.connect_to_signal("PortsConnected", self.__connection)
  379.     jack_control_ifa.connect_to_signal("PortsDisconnected", self.__disconnection)
  380.  
  381.   def keypress(self, widget, event):
  382.     for category in [0,2,3]:
  383.       i = 0
  384.       for keyval in self.keyvals[category]:
  385.         if event.keyval == keyval:
  386.           value = self.RoutesButtons[category][i].get_active()
  387.           self.RoutesButtons[category][i].set_active(not value)
  388.         i += 1
  389.  
  390.   def hide_buttons(self):
  391.     for button in self.RoutesButtons[0]+self.RoutesButtons[2]+self.RoutesButtons[3]:
  392.        button.hide()
  393.  
  394.   def __create_model(self, num):
  395.     for client in categorized_ports[num]:
  396.       iter = self.TreeStores[num].append(None)
  397.       self.TreeStores[num].set(iter,
  398.                 0, client[0],
  399.                 1, client[1])
  400.       for port in client[2]:
  401.         child_iter = self.TreeStores[num].append(iter)
  402.         self.TreeStores[num].set(child_iter,
  403.                   0, port[0],
  404.                   1, port[1])
  405.         category = int(isInputOrOutput(port[2]) == "output") + int(port[3] == 1) * 2
  406.         caID = getID(client[0], clients, 0)
  407.         if not category in clients[caID][2]:
  408.           clients[caID][2].append(category)
  409.  
  410.   def __add_client (self, new_graph_version, client_id, client_name):
  411.     caID = getID(client_name, clients, 1)
  412.     if caID == None:
  413.       clients.append([client_id, client_name, [], True])
  414.     else:
  415.       clients[caID][0] = client_id
  416.       clients[caID][3] = True
  417.       for instance in [i+4 for i in clients[caID][2]]:
  418.         changed_client = search_tree(self.TreeStores[instance], self.TreeStores[instance].iter_children(None), match_func_tree, (1, client_name))
  419.         self.TreeStores[instance].set(changed_client, 0, client_id)
  420.  
  421.   def __add_port (self, new_graph_version, client_id, client_name, port_id, port_name, port_flags, port_type):
  422.     paID = getID(port_name, ports, 2)
  423.     if paID == None:
  424.       category = int(isInputOrOutput(port_flags) == "output") + int(port_type == 1) * 2
  425.       # Primero hay que agregar los clientes
  426.       # a las bases de datos que corresponda
  427.       in_client = search_tree(self.TreeStores[category], self.TreeStores[category].iter_children(None), match_func_tree, (0, client_id))
  428.       if not in_client:
  429.         # Y aprovechamos de agregar las instancias del cliente
  430.         clients[getID(client_id, clients, 0)][2].append(category)
  431.         iter = self.TreeStores[category].append(None)
  432.         self.TreeStores[category].set(iter,
  433.                                       0, client_id,
  434.                                       1, client_name)
  435.       # Ahora agregamos los puertos
  436.       in_client = search_tree(self.TreeStores[category], self.TreeStores[category].iter_children(None), match_func_tree, (0, client_id))
  437.       child_iter = self.TreeStores[category].append(in_client)
  438.       self.TreeStores[category].set(child_iter,
  439.                                     0, port_id,
  440.                                     1, port_name)
  441.       ports.append([client_id, port_id, port_name, port_flags, port_type, False, True])
  442.     else:
  443.       ports[paID][0] = client_id
  444.       ports[paID][1] = port_id
  445.       ports[paID][6] = True
  446.       category = int(isInputOrOutput(port_flags) == "output") + int(port_type == 1) * 2 + 4
  447.       in_client = search_tree(self.TreeStores[category], self.TreeStores[category].iter_children(None), match_func_tree, (1, client_name))
  448.       changed_port = search_tree(self.TreeStores[category], self.TreeStores[category].iter_children(in_client), match_func_tree, (1, port_name))
  449.       self.TreeStores[category].set(changed_port, 0, port_id)
  450.  
  451.   def __del_client (self, new_graph_version, client_id, client_name):
  452.     caID = getID(client_id, clients, 0)
  453.     instances = clients[caID][2]
  454.     for instance in instances:
  455.       disappeared_client = search_tree(self.TreeStores[instance], self.TreeStores[instance].iter_children(None), match_func_tree, (0, client_id))
  456.       if disappeared_client:
  457.         self.TreeStores[instance].remove(disappeared_client)
  458.     # Si el cliente tiene algún puerto seleccionado se borra
  459.     # Si no se cambia su estado a inactivo
  460.     some_port_selected = False
  461.     for port in ports:
  462.        if port[5] == True:
  463.          some_port_selected = True
  464.          break
  465.     if some_port_selected:
  466.       clients[caID][3] = False
  467.     else:
  468.       del clients[caID]
  469.  
  470.   def __del_port (self, new_graph_version, client_id, client_name, port_id, port_name):
  471.     paID = getID(port_id, ports, 1)
  472.     caID = getID(client_id, clients, 0)
  473.     port_flags, port_type, port_selected = ports[paID][3:6]
  474.     category = int(isInputOrOutput(port_flags) == "output") + int(port_type == 1) * 2
  475.     category_b = category + int(ports[paID][5])*4
  476.     not_category = category + int(not ports[paID][5])*4
  477.     # Si el puerto está seleccionado no lo borramos
  478.     # sólo se cambia su estado a inactivo
  479.     if port_selected:
  480.       ports[paID][6] = False
  481.     else:
  482.       # Primero borramos el puerto
  483.       in_client = search_tree(self.TreeStores[category_b], self.TreeStores[category_b].iter_children(None), match_func_tree, (0, client_id))
  484.       if in_client:
  485.         disappeared_port = search_tree(self.TreeStores[category_b], self.TreeStores[category_b].iter_children(in_client), match_func_tree, (0, port_id))
  486.         self.TreeStores[category_b].remove(disappeared_port)
  487.       del ports[paID]
  488.       # Si el cliente no tiene puertos en la categoría
  489.       # borrar el cliente y las instancias
  490.       empty_client = search_tree(self.TreeStores[category_b], self.TreeStores[category_b].iter_children(None), match_func_tree, (0, client_id))
  491.       ppc = get_tree_len(self.TreeStores[category_b], self.TreeStores[category_b].iter_children(empty_client))
  492.       if ppc == 0:
  493.         self.TreeStores[category_b].remove(empty_client)
  494.       empty_not_client = search_tree(self.TreeStores[not_category], self.TreeStores[not_category].iter_children(None), match_func_tree, (0, client_id))
  495.       ppnc = get_tree_len(self.TreeStores[not_category], self.TreeStores[not_category].iter_children(empty_not_client))
  496.       if ppc == 0 and ppnc == 0:
  497.         clients[caID][2].remove(category)
  498.  
  499.   def __connection(self, new_graph_version, client1_id, client1_name, port1_id, port1_name, client2_id, client2_name, port2_id, port2_name, connection_id):
  500.     connections.append([client1_id, client1_name, port1_id, port1_name, client2_id, client2_name, port2_id, port2_name, connection_id])
  501.  
  502.   def __disconnection(self, new_graph_version, client1_id, client1_name, port1_id, port1_name, client2_id, client2_name, port2_id, port2_name, connection_id):
  503.     coaID = getID(connection_id, connections, 8)
  504.     del connections[coaID]
  505.  
  506.   def __sel_item(self, widget, model, treeView, model_sel, max_items = 1):
  507.     ### -- Selección en pestaña Puertos -- ###
  508.     treeselection = treeView.get_selection()
  509.     (sel_model, pathlist) = treeselection.get_selected_rows()
  510.     sel_iter = model.get_iter(pathlist[0])
  511.     parent = model.iter_parent(sel_iter)
  512.     error = False
  513.     if treeselection.count_selected_rows() > 1:
  514.       if not parent:
  515.         msg = "La selección múltiple solo puede contener puertos no clientes"
  516.         dialog = Gtk.MessageDialog(self,
  517.                  Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
  518.                  Gtk.MessageType.INFO, Gtk.ButtonsType.OK, msg)
  519.         dialog.run()
  520.         dialog.destroy()
  521.         error = True
  522.       else:
  523.         for path in pathlist:
  524.           citer = model.get_iter(path)
  525.           piter = model.iter_parent(citer)
  526.           if not model.get_value(parent, 0) == model.get_value(piter, 0):
  527.             msg = "Todos los puertos deben ser del mismo cliente"
  528.             dialog = Gtk.MessageDialog(self,
  529.                      Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
  530.                      Gtk.MessageType.INFO, Gtk.ButtonsType.OK, msg)
  531.             dialog.run()
  532.             dialog.destroy()
  533.             error = True
  534.             break
  535.     if not error:
  536.       if parent:
  537.         parent_id = model.get_value(parent, 0)
  538.         parent_name = model.get_value(parent, 1)
  539.         children_colection = []
  540.         children_iters = []
  541.         for item in pathlist:
  542.           child_iter = model.get_iter(item)
  543.           child_id = model.get_value(child_iter, 0)
  544.           child_name = model.get_value(child_iter, 1)
  545.           children_colection.append([child_id, child_name])
  546.           children_iters.append(child_iter)
  547.         if len(children_colection) <= max_items:
  548.           for item in children_iters:
  549.             model.remove(item)
  550.           children_len = len(get_tree(model, model.iter_children(parent)))
  551.           if not children_len:
  552.             model.remove(parent)
  553.         else:
  554.           msg = "Error la seleccion contiene " + str(len(children_colection)) + " puertos, solo se admite " + str(max_items)
  555.           dialog = Gtk.MessageDialog(self,
  556.                    Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
  557.                    Gtk.MessageType.INFO, Gtk.ButtonsType.OK, msg)
  558.           dialog.run()
  559.           dialog.destroy()
  560.           error = True
  561.       else:
  562.         children_iters = get_tree(model, model.iter_children(sel_iter))
  563.         children_colection = []
  564.         for item in children_iters:
  565.           child_id = model.get_value(item, 0)
  566.           child_name = model.get_value(item, 1)
  567.           children_colection.append([child_id, child_name])
  568.         children_len = len(children_colection)
  569.         if children_len <= max_items:
  570.           parent_id = model.get_value(sel_iter, 0)
  571.           parent_name = model.get_value(sel_iter, 1)
  572.           for item in children_iters:
  573.             model.remove(item)
  574.           model.remove(sel_iter)
  575.         else:
  576.           msg = "Error la seleccion contiene " + str(children_len) + " puertos, solo se admite " + str(max_items)
  577.           dialog = Gtk.MessageDialog(self,
  578.                    Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
  579.                    Gtk.MessageType.INFO, Gtk.ButtonsType.OK, msg)
  580.           dialog.run()
  581.           dialog.destroy()
  582.           error = True
  583.     if not error:
  584.       paID = getID(child_id, ports, 1)
  585.       selected = ports[paID][5]
  586.       exist = ports[paID][6]
  587.       if exist:
  588.         if selected:
  589.           iter = search_tree(model_sel, model_sel.iter_children(None), match_func_tree, (0, parent_id))
  590.         if not selected or not iter:
  591.           iter = model_sel.append(None)
  592.           model_sel.set(iter,
  593.                         0, parent_id,
  594.                         1, parent_name)
  595.         for item in children_colection:
  596.           child_iter = model_sel.append(iter)
  597.           child_id, child_name = item
  598.           model_sel.set(child_iter,
  599.                         0, child_id,
  600.                         1, child_name)
  601.           paID = getID(child_id, ports, 1)
  602.           ports[paID][5] = not ports[paID][5]
  603.     ## -- Selección en pestaña Salidas -- ##
  604.     """ Estoy pensando como voy a hacer esta parte
  605.        Creo que serán conexiones semejantes a qjackctl
  606.        De momento estoy pensando en cómo hacerlo"""
  607.     ## -- Selección en pestaña Rutas -- ##
  608.     if not error:
  609.       port_flags, port_type, port_selected = ports[paID][3:6]
  610.       category = int(isInputOrOutput(port_flags) == "output") + int(port_type == 1) * 2
  611.       elements = get_tree(self.TreeStores[category + 4], self.TreeStores[category + 4].iter_children(None))
  612.       i = 0
  613.       for element in elements:
  614.         children = self.TreeStores[category + 4].iter_children(element)
  615.         txt1 = self.keymap[category][i]
  616.         txt2 = self.TreeStores[category + 4].get_value(element, 1)
  617.         txt3 = self.TreeStores[category + 4].get_value(children, 1)
  618.         txt = txt1 + "\n" + txt2 + "\n" + txt3
  619.         self.RoutesLabels[category][i].set_text(txt)
  620.         self.RoutesButtons[category][i].show()
  621.         i += 1
  622.       nbut = len(self.RoutesButtons[category])
  623.       while i < nbut:
  624.         self.RoutesButtons[category][i].hide()
  625.         i += 1
  626.       # Reseteamos todos los botones
  627.       for i in [0,2,3]:
  628.         for button in self.RoutesButtons[i]:
  629.           button.set_active(False)
  630.       # Si hemos seleccionado un teclado
  631.       # reseteamos el teclado seleccionado
  632.       if category == 3:
  633.         self.keyboard_selected = None
  634.  
  635.   def __keyboard(self, widget, index):
  636.     active = widget.get_active()
  637.     if active:
  638.       # Primero cerramos todos los teclados que no estemos usando
  639.       i = 0
  640.       for button in self.RoutesButtons[3]:
  641.         if not i == index:
  642.           button.set_active(False)
  643.         i += 1
  644.       # Segundo buscamos el cliente y el puerto del teclado seleccionado
  645.       client_iter = self.TreeStores[7].get_iter(index)
  646.       client_id = self.TreeStores[7].get_value(client_iter, 0)
  647.       client_name = self.TreeStores[7].get_value(client_iter, 1)
  648.       port_iter = self.TreeStores[7].iter_children(client_iter)
  649.       port_id = self.TreeStores[7].get_value(port_iter, 0)
  650.       port_name = self.TreeStores[7].get_value(port_iter, 1)
  651.       self.keyboard_selected = [client_id, client_name, port_id, port_name]
  652.       # Tercero buscamos los sintetizadores conectados al teclado
  653.       iter = self.TreeStores[6].get_iter_first()
  654.       i = 0
  655.       self.lock_synths = True
  656.       while iter:
  657.         c_client_id = self.TreeStores[6].get_value(iter, 0)
  658.         c_client_name = self.TreeStores[6].get_value(iter, 1)
  659.         iter_children = self.TreeStores[6].iter_children(iter)
  660.         c_port_id = self.TreeStores[6].get_value(iter_children, 0)
  661.         connected = False
  662.         for connection in connections:
  663.           if client_id == connection[0] and port_id == connection[2] and c_client_id == connection[4] and c_port_id == connection[6]:
  664.             self.RoutesButtons[2][i].set_active(True)
  665.             connected = True
  666.         if not connected:
  667.           self.RoutesButtons[2][i].set_active(False)
  668.         iter = self.TreeStores[6].iter_next(iter)
  669.         i += 1
  670.       self.lock_synths = False
  671.  
  672.   def __connect_synth(self, widget, index):
  673.     pass
  674.     active = widget.get_active()
  675.     if not self.lock_synths:
  676.       if active:
  677.         # Desactivamos los clientes no seleccionados
  678.         # Si no está seleccionado múltiples sintetizadores
  679.         if not self.multiple_synth.get_active():
  680.           i = 0
  681.           for button in self.RoutesButtons[2]:
  682.             if not i == index:
  683.               button.set_active(False)
  684.             i += 1
  685.         # Buscamos el cliente y el puerto del sintetizador
  686.         # Y lo conectamos al teclado
  687.         client_iter = self.TreeStores[6].get_iter(index)
  688.         port_iter = self.TreeStores[6].iter_children(client_iter)
  689.         port_id = self.TreeStores[6].get_value(port_iter, 0)
  690.         jack_control_ifa.ConnectPortsByID(self.keyboard_selected[2], port_id)
  691.       else:
  692.         # Si se desselecciona el cliente desconectamos el sintetizador
  693.         client_iter = self.TreeStores[6].get_iter(index)
  694.         port_iter = self.TreeStores[6].iter_children(client_iter)
  695.         port_id = self.TreeStores[6].get_value(port_iter, 0)
  696.         jack_control_ifa.DisconnectPortsByID(self.keyboard_selected[2], port_id)
  697.  
  698. win = MyWindow()
  699. win.connect("delete-event", Gtk.main_quit)
  700. win.show_all()
  701. win.hide_buttons()
  702. Gtk.main()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!