falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Browse Source

Massive internal fixing

tags/v0.9.0
falkTX 13 years ago
parent
177cc39c5f
commit
c0457cf465
15 changed files with 790 additions and 531 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -6
      src/catarina.py
  2. +15
    -7
      src/catia.py
  3. +12
    -16
      src/claudia.py
  4. +2
    -0
      src/digitalpeakmeter.py
  5. +468
    -246
      src/jacklib.py
  6. +1
    -1
      src/jackmeter.py
  7. +22
    -18
      src/jacksettings.py
  8. +4
    -4
      src/logs.py
  9. +2
    -2
      src/render.py
  10. +39
    -39
      src/shared.py
  11. +38
    -38
      src/shared_canvas.py
  12. +149
    -151
      src/shared_jack.py
  13. +2
    -2
      src/shared_settings.py
  14. +32
    -0
      src/ui/claudia.ui
  15. +1
    -1
      src/xycontroller.py

+ 3
- 6
src/catarina.py View File

@@ -22,7 +22,7 @@ from PyQt4.QtGui import QApplication, QDialog, QDialogButtonBox, QMainWindow, QT
from PyQt4.QtXml import QDomDocument

# Imports (Custom Stuff)
import ui_catarina, icons_rc
import ui_catarina
import ui_catarina_addgroup, ui_catarina_removegroup, ui_catarina_renamegroup
import ui_catarina_addport, ui_catarina_removeport, ui_catarina_renameport
import ui_catarina_connectports, ui_catarina_disconnectports
@@ -808,21 +808,18 @@ class CatarinaMainW(QMainWindow, ui_catarina.Ui_CatarinaMainW):
content += "</CATARINA>\n"

try:
if (open(path, "w").write(content) == False):
raiseError
open(path, "w").write(content)
except:
QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to save file"))

def loadFile(self, path):
if (os.path.exists(path) == False):
if (not os.path.exists(path)):
QMessageBox.critical(self, self.tr("Error"), self.tr("The file '%s' does not exist" % (path)))
self.m_save_path = None
return

try:
read = open(path, "r").read()
if (not read):
raiseError
except:
QMessageBox.critical(self, self.tr("Error"), self.tr("Failed to load file"))
self.m_save_path = None


+ 15
- 7
src/catia.py View File

@@ -39,6 +39,9 @@ try:
except:
haveDBus = False

global a2j_client_name
a2j_client_name = None

iGroupId = 0
iGroupName = 1

@@ -276,6 +279,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
QMessageBox.information(self, self.tr("Port Information"), info)

elif (action == patchcanvas.ACTION_PORT_RENAME):
global a2j_client_name

port_id = value1
port_short_name = unicode2ascii(value_str)

@@ -386,7 +391,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
jacklib.set_session_callback(jack.client, self.JackSessionCallback, None)
jacklib.on_shutdown(jack.client, self.JackShutdownCallback, None)

if (JACK2):
if (jacklib.JACK2):
jacklib.set_port_rename_callback(jack.client, self.JackPortRenameCallback, None)

def init_ports(self):
@@ -405,6 +410,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
a2j_name_list = []
port_name_list = c_char_p_p_to_list(jacklib.get_ports(jack.client, "", "", 0))

global a2j_client_name

h = 0
for i in range(len(port_name_list)):
if (port_name_list[i-h].split(":")[0] == a2j_client_name):
@@ -417,8 +424,6 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):

del a2j_name_list

import hashlib

# Add ports
for port_name in port_name_list:
port_ptr = jacklib.port_by_name(jack.client, port_name)
@@ -435,7 +440,6 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
port_connection_names = c_char_p_p_to_list(jacklib.port_get_all_connections(jack.client, port_ptr))

for port_con_name in port_connection_names:
port_con_ptr = jacklib.port_by_name(jack.client, port_con_name)
self.canvas_connect_ports(port_name, port_con_name)

def canvas_add_group(self, group_name):
@@ -465,6 +469,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
patchcanvas.removeGroup(group_id)

def canvas_add_port(self, port_ptr, port_name):
global a2j_client_name

port_id = self.m_last_port_id
group_id = -1

@@ -489,13 +495,11 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
port_mode = patchcanvas.PORT_MODE_NULL

if (group_name == a2j_client_name):
haveA2J = True
port_type = patchcanvas.PORT_TYPE_MIDI_A2J
group_name = port_name.replace("%s:" % (a2j_client_name), "", 1).split(" [", 1)[0]
port_short_name = port_name.split("): ", 1)[1]

else:
haveA2J = False
port_short_name = port_name.replace("%s:" % (group_name), "", 1)

port_type_str = str(jacklib.port_type(port_ptr), encoding="ascii")
@@ -602,7 +606,7 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):

def jackStarted(self):
if (not jack.client):
jack.client = jacklib.client_open_uuid("catia", jacklib.JackNoStartServer|jacklib.JackSessionID, None, "")
jack.client = jacklib.client_open("catia", jacklib.JackNoStartServer|jacklib.JackSessionID, None)
if (not jack.client):
return self.jackStopped()

@@ -719,6 +723,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):
self.a2jStopped()

def DBusReconnect(self):
global a2j_client_name

try:
DBus.jack = DBus.bus.get_object("org.jackaudio.service", "/org/jackaudio/Controller")
jacksettings.initBus(DBus.bus)
@@ -902,6 +908,8 @@ class CatiaMainW(QMainWindow, ui_catia.Ui_CatiaMainW):

@pyqtSlot()
def slot_handleCrash_a2j(self):
global a2j_client_name

try:
DBus.a2j = dbus.Interface(DBus.bus.get_object("org.gna.home.a2jmidid", "/"), "org.gna.home.a2jmidid.control")
a2j_client_name = str(DBus.a2j.get_jack_client_name())


+ 12
- 16
src/claudia.py View File

@@ -307,7 +307,7 @@ class ProjectNameW(QDialog, ui_claudia_projectname.Ui_ProjectNameW):
def slot_checkFolder(self):
# Create default project folder if the project has not been set yet
if (not self.le_path.text()):
if (os.path.exists(self.m_proj_folder) == False):
if (not os.path.exists(self.m_proj_folder)):
os.mkdir(self.m_proj_folder)

if (self.le_path.text()):
@@ -405,7 +405,7 @@ class RunCustomW(QDialog, ui_claudia_runcustom.Ui_RunCustomW):
else:
self.rb_level_0.setChecked(True)

if (isRoom == False):
if (not isRoom):
self.rb_level_lash.setEnabled(False)
self.rb_level_js.setEnabled(False)

@@ -865,7 +865,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
studio_iface = dbus.Interface(DBus.ladish_studio, 'org.ladish.AppSupervisor')
studio_item = self.treeWidget.topLevelItem(0)

graph_version, app_list = DBus.ladish_app_iface.GetAll2()
graph_version, app_list = studio_iface.GetAll2()

for app in app_list:
number, name, active, terminal, level = app
@@ -882,7 +882,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
text += "L"
text += level.upper()
text += "] "
if (active == False):
if (not active):
text += "(inactive) "
text += name

@@ -918,7 +918,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
text += "L"
text += level.upper()
text += "] "
if (active == False):
if (not active):
text += "(inactive) "
text += name

@@ -976,7 +976,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):

# Remove old unused item if needed
iItem = self.treeWidget.topLevelItem(room_index)
if (iItem and iItem.isVisible() == False):
if (iItem and not iItem.isVisible()):
self.treeWidget.takeTopLevelItem(room_index)

# Insert padding of items if needed
@@ -989,12 +989,8 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
graph_version, project_properties = room_project_properties

if (len(project_properties) > 0):
project_path = str(project_properties['dir'])
project_name = str(project_properties['name'])
item_string = " (%s)" % (project_name)
item_string = " (%s)" % (project_properties['name'])
else:
project_path = None
project_name = None
item_string = ""

prop_obj = [None, None]
@@ -2005,7 +2001,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):

if (item and item.type() == ITEM_TYPE_ROOM and item.properties[iItemPropRoomPath] == room_path):
for j in range(item.childCount()):
top_level_item.takeChild(j)
item.takeChild(j)

self.treeWidget.takeTopLevelItem(i)
break
@@ -2083,7 +2079,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
text += "L"
text += level.upper()
text += "] "
if (active == False):
if (not active):
text += "(inactive) "
text += name

@@ -2137,7 +2133,7 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
text += "L"
text += level.upper()
text += "] "
if (active == False):
if (not active):
text += "(inactive) "
text += name

@@ -2266,8 +2262,8 @@ class ClaudiaMainW(QMainWindow, ui_claudia.Ui_ClaudiaMainW):
def saveSettings(self):
self.settings.setValue("Geometry", self.saveGeometry())
self.settings.setValue("SplitterSizes", self.splitter.saveState())
self.settings.setValue("ShowToolbar", self.frame_toolbar.isVisible())
self.settings.setValue("ShowStatusbar", self.frame_statusbar.isVisible())
self.settings.setValue("ShowToolbar", self.frame_toolbar.isEnabled())
self.settings.setValue("ShowStatusbar", self.frame_statusbar.isEnabled())
self.settings.setValue("TransportView", self.m_selected_transport_view)
self.settings.setValue("HorizontalScrollBarValue", self.graphicsView.horizontalScrollBar().value())
self.settings.setValue("VerticalScrollBarValue", self.graphicsView.verticalScrollBar().value())


+ 2
- 0
src/digitalpeakmeter.py View File

@@ -224,6 +224,8 @@ class DigitalPeakMeter(QWidget):
painter.setPen(QColor(110, 15, 15, 100))
painter.drawLine(1, lsmall-(lsmall/1.04), lfull, lsmall-(lsmall/1.04))

QWidget.paintEvent(self, event)

def resizeEvent(self, event):
self.updateSizes()
QWidget.resizeEvent(self, event)

+ 468
- 246
src/jacklib.py
File diff suppressed because it is too large
View File


+ 1
- 1
src/jackmeter.py View File

@@ -131,7 +131,7 @@ if __name__ == '__main__':

# JACK initialization
jack_status = jacklib.jack_status_t(0)
client = jacklib.client_open_uuid("M", jacklib.JackSessionID, jacklib.pointer(jack_status), "")
client = jacklib.client_open("M", jacklib.JackSessionID, jacklib.pointer(jack_status))

if not client:
QMessageBox.critical(None, app.translate("MeterW", "Error"), app.translate("MeterW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))


+ 22
- 18
src/jacksettings.py View File

@@ -86,13 +86,13 @@ def engineHasFeature(feature):
return bool(dbus.String(feature) in feature_list)

def getEngineParameter(parameter, error):
if (engineHasFeature(parameter) == False):
if (not engineHasFeature(parameter)):
return error
else:
return jackctl.GetParameterValue(["engine",parameter])[2]

def setEngineParameter(parameter, value, optional=True):
if (engineHasFeature(parameter) == False):
if (not engineHasFeature(parameter)):
return False
elif (optional):
if (value != jackctl.GetParameterValue(["engine",parameter])[2]):
@@ -110,13 +110,13 @@ def driverHasFeature(feature):
return bool(dbus.String(feature) in feature_list)

def getDriverParameter(parameter, error):
if (driverHasFeature(parameter) == False):
if (not driverHasFeature(parameter)):
return error
else:
return jackctl.GetParameterValue(["driver",parameter])[2]

def setDriverParameter(parameter, value, optional=True):
if (driverHasFeature(parameter) == False):
if (not driverHasFeature(parameter)):
return False
elif (optional):
if (value != jackctl.GetParameterValue(["driver",parameter])[2]):
@@ -157,7 +157,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
self.connect(self.buttonBox.button(QDialogButtonBox.Reset), SIGNAL("clicked()"), SLOT("slot_resetJackSettings()"))

self.connect(self.obj_driver_duplex, SIGNAL("clicked(bool)"), SLOT("slot_checkDuplexSelection(bool)"))
self.connect(self.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), SLOT("slot_checkDriverSelection(int, int, int, int)"))
self.connect(self.obj_server_driver, SIGNAL("currentCellChanged(int, int, int, int)"), SLOT("slot_checkDriverSelection(int)"))

self.connect(self.obj_driver_capture, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
self.connect(self.obj_driver_playback, SIGNAL("currentIndexChanged(int)"), SLOT("slot_checkALSASelection()"))
@@ -201,7 +201,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
self.obj_server_self_connect_mode.setEnabled(engineHasFeature("self-connect-mode"))

# Disable clock-source if not on Linux
if (LINUX == False):
if (not LINUX):
self.obj_server_clock_source.setEnabled(False)

# -------------------------------------------------------------
@@ -232,7 +232,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
value = dbus.Int32(int(self.obj_server_client_timeout.currentText()))
setEngineParameter("client-timeout", value, True)

if (self.obj_server_clock_source.isEnabled() or 1):
if (self.obj_server_clock_source.isEnabled()):
value = None
if (self.obj_server_clock_source_system.isChecked()):
if (self.m_server_clock_source_broken):
@@ -472,7 +472,10 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
print("JackSettings::saveDriverSettings() - Cannot save midi-driver value")

if (value != None):
setDriverParameter("midi-driver", value, True)
if (driverHasFeature("midi")):
setDriverParameter("midi", value, True)
else:
setDriverParameter("midi-driver", value, True)

if (self.obj_driver_wait.isEnabled()):
value = dbus.UInt32(self.obj_driver_wait.value())
@@ -553,7 +556,7 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
self.obj_driver_input_latency.setValue(int(value))
elif (attribute == "output-latency"):
self.obj_driver_output_latency.setValue(int(value))
elif (attribute == "midi-driver"):
elif (attribute in ("midi", "midi-driver")):
value = str(value)
if (value == "none"):
self.obj_driver_midi_driver.setCurrentIndex(0)
@@ -611,8 +614,8 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):

self.slot_checkALSASelection()

@pyqtSlot(int, int, int, int)
def slot_checkDriverSelection(self, row, column, prev_row, prev_column):
@pyqtSlot(int)
def slot_checkDriverSelection(self, row):
# Save previous settings
self.saveDriverSettings()

@@ -681,8 +684,8 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
self.obj_driver_input_latency_label.setEnabled(driverHasFeature("input-latency"))
self.obj_driver_output_latency.setEnabled(driverHasFeature("output-latency"))
self.obj_driver_output_latency_label.setEnabled(driverHasFeature("output-latency"))
self.obj_driver_midi_driver.setEnabled(driverHasFeature("midi-driver"))
self.obj_driver_midi_driver_label.setEnabled(driverHasFeature("midi-driver"))
self.obj_driver_midi_driver.setEnabled(driverHasFeature("midi") or driverHasFeature("midi-driver"))
self.obj_driver_midi_driver_label.setEnabled(driverHasFeature("midi") or driverHasFeature("midi-driver"))
self.obj_driver_wait.setEnabled(driverHasFeature("wait"))
self.obj_driver_wait_label.setEnabled(driverHasFeature("wait"))
self.obj_driver_verbose.setEnabled(driverHasFeature("verbose"))
@@ -737,20 +740,21 @@ class JackSettingsW(QDialog, ui_settings_jack.Ui_JackSettingsW):
if __name__ == '__main__':

# Additional imports
import sys, icons_rc
import icons_rc
from sys import argv as sys_argv, exit as sys_exit
from PyQt4.QtGui import QApplication, QIcon

# App initialization
app = QApplication(sys.argv)
app = QApplication(sys_argv)

# Connect to DBus
if (dbus):
if (initBus(dbus.SessionBus())):
QMessageBox.critical(None, app.translate("JackSettingsW", "Error"), app.translate("JackSettingsW", "jackdbus is not available!\nIs not possible to configure JACK at this point."))
sys.exit(1)
sys_exit(1)
else:
QMessageBox.critical(None, app.translate("JackSettingsW", "Error"), app.translate("JackSettingsW", "DBus is not available, cannot continue."))
sys.exit(1)
sys_exit(1)

# Show GUI
gui = JackSettingsW(None)
@@ -758,4 +762,4 @@ if __name__ == '__main__':
gui.show()

# App-Loop
sys.exit(app.exec_())
sys_exit(app.exec_())

+ 4
- 4
src/logs.py View File

@@ -243,22 +243,22 @@ class LogsW(QDialog, ui_logs.Ui_LogsW):

tab_index = 0

if (os.path.exists(self.LOG_FILE_JACK) == False):
if (not os.path.exists(self.LOG_FILE_JACK)):
self.LOG_FILE_JACK = None
self.tabWidget.removeTab(0-tab_index)
tab_index += 1

if (os.path.exists(self.LOG_FILE_A2J) == False):
if (not os.path.exists(self.LOG_FILE_A2J)):
self.LOG_FILE_A2J = None
self.tabWidget.removeTab(1-tab_index)
tab_index += 1

if (os.path.exists(self.LOG_FILE_LASH) == False):
if (not os.path.exists(self.LOG_FILE_LASH)):
self.LOG_FILE_LASH = None
self.tabWidget.removeTab(2-tab_index)
tab_index += 1

if (os.path.exists(self.LOG_FILE_LADISH) == False):
if (not os.path.exists(self.LOG_FILE_LADISH)):
self.LOG_FILE_LADISH = None
self.tabWidget.removeTab(3-tab_index)
tab_index += 1


+ 2
- 2
src/render.py View File

@@ -105,7 +105,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):

@pyqtSlot()
def slot_renderStart(self):
if (os.path.exists(self.le_folder.text()) == False):
if (not os.path.exists(self.le_folder.text())):
QMessageBox.warning(self, self.tr("Warning"), self.tr("The selected directory does not exist. Please choose a valid one."))
return

@@ -255,7 +255,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
time = jacklib.get_current_transport_frame(self.m_jack_client)/self.m_sample_rate
self.progressBar.setValue(time)

if (time > self.m_max_time or (self.m_last_time > time and self.m_freewheel == False)):
if (time > self.m_max_time or (self.m_last_time > time and not self.m_freewheel)):
self.slot_renderStop()

self.m_last_time = time


+ 39
- 39
src/shared.py View File

@@ -38,7 +38,7 @@ else:
LINUX = False
WINDOWS = False

if (WINDOWS == False):
if (not WINDOWS):
from signal import signal, SIGINT, SIGTERM, SIGUSR1, SIGUSR2

# Set Version
@@ -56,7 +56,7 @@ HOME = os.getenv("HOME")
if (HOME == None):
qWarning("HOME variable not set")
HOME = "/tmp"
elif (os.path.exists(HOME) == False):
elif (not os.path.exists(HOME)):
qWarning("HOME variable set but not valid")
HOME = "/tmp"

@@ -201,15 +201,15 @@ def getIcon(icon, size=16):
return QIcon.fromTheme(icon, QIcon(":/%ix%i/%s.png" % (size, size, icon)))

# QLineEdit and QPushButtom combo
def getAndSetPath(self, currentPath, lineEdit):
newPath = QFileDialog.getExistingDirectory(self, self.tr("Set Path"), currentPath, QFileDialog.ShowDirsOnly)
def getAndSetPath(self_, currentPath, lineEdit):
newPath = QFileDialog.getExistingDirectory(self_, self_.tr("Set Path"), currentPath, QFileDialog.ShowDirsOnly)
if (newPath):
lineEdit.setText(newPath)
return newPath

# Custom MessageBox
def CustomMessageBox(self, icon, title, text, extraText="", buttons=QMessageBox.Yes|QMessageBox.No, defButton=QMessageBox.No):
msgBox = QMessageBox(self)
def CustomMessageBox(self_, icon, title, text, extraText="", buttons=QMessageBox.Yes|QMessageBox.No, defButton=QMessageBox.No):
msgBox = QMessageBox(self_)
msgBox.setIcon(icon)
msgBox.setWindowTitle(title)
msgBox.setText(text)
@@ -233,7 +233,7 @@ def set_up_signals(_gui):
x_gui.connect(x_gui, SIGNAL("SIGUSR2()"), lambda gui=x_gui: showWindow(gui))
x_gui.connect(x_gui, SIGNAL("SIGTERM()"), SLOT("close()"))

def signal_handler(sig=0, frame=0):
def signal_handler(sig):
global x_gui
if (sig in (SIGINT, SIGTERM)):
x_gui.emit(SIGNAL("SIGTERM()"))
@@ -242,45 +242,45 @@ def signal_handler(sig=0, frame=0):
elif (sig == SIGUSR2):
x_gui.emit(SIGNAL("SIGUSR2()"))

def showWindow(self):
if (self.isMaximized()):
self.showMaximized()
def showWindow(self_):
if (self_.isMaximized()):
self_.showMaximized()
else:
self.showNormal()
self_.showNormal()

# Shared Icons
def setIcons(self, modes):
def setIcons(self_, modes):
if ("canvas" in modes):
self.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
self.act_canvas_refresh.setIcon(getIcon("view-refresh"))
self.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
self.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
self.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
self.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
self.act_canvas_print.setIcon(getIcon("document-print"))
self.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
self.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
self.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
self.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
self_.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
self_.act_canvas_refresh.setIcon(getIcon("view-refresh"))
self_.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
self_.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
self_.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
self_.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
self_.act_canvas_print.setIcon(getIcon("document-print"))
self_.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
self_.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
self_.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
self_.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))

if ("jack" in modes):
self.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
self.act_jack_configure.setIcon(getIcon("configure"))
self.act_jack_render.setIcon(getIcon("media-record"))
self.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
self.b_jack_configure.setIcon(getIcon("configure"))
self.b_jack_render.setIcon(getIcon("media-record"))
self_.act_jack_clear_xruns.setIcon(getIcon("edit-clear"))
self_.act_jack_configure.setIcon(getIcon("configure"))
self_.act_jack_render.setIcon(getIcon("media-record"))
self_.b_jack_clear_xruns.setIcon(getIcon("edit-clear"))
self_.b_jack_configure.setIcon(getIcon("configure"))
self_.b_jack_render.setIcon(getIcon("media-record"))

if ("transport" in modes):
self.act_transport_play.setIcon(getIcon("media-playback-start"))
self.act_transport_stop.setIcon(getIcon("media-playback-stop"))
self.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
self.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
self.b_transport_play.setIcon(getIcon("media-playback-start"))
self.b_transport_stop.setIcon(getIcon("media-playback-stop"))
self.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
self.b_transport_forwards.setIcon(getIcon("media-seek-forward"))
self_.act_transport_play.setIcon(getIcon("media-playback-start"))
self_.act_transport_stop.setIcon(getIcon("media-playback-stop"))
self_.act_transport_backwards.setIcon(getIcon("media-seek-backward"))
self_.act_transport_forwards.setIcon(getIcon("media-seek-forward"))
self_.b_transport_play.setIcon(getIcon("media-playback-start"))
self_.b_transport_stop.setIcon(getIcon("media-playback-stop"))
self_.b_transport_backwards.setIcon(getIcon("media-seek-backward"))
self_.b_transport_forwards.setIcon(getIcon("media-seek-forward"))

if ("misc" in modes):
self.act_quit.setIcon(getIcon("application-exit"))
self.act_configure.setIcon(getIcon("configure"))
self_.act_quit.setIcon(getIcon("application-exit"))
self_.act_configure.setIcon(getIcon("configure"))

+ 38
- 38
src/shared_canvas.py View File

@@ -24,41 +24,41 @@ from PyQt4.QtGui import QFileDialog, QImage, QPainter, QPrinter, QPrintDialog
import patchcanvas

# Shared Canvas code
def canvas_arrange(self):
def canvas_arrange():
patchcanvas.arrange()

def canvas_refresh(self):
def canvas_refresh(self_):
patchcanvas.clear()
self.init_ports()
self_.init_ports()

def canvas_zoom_fit(self):
self.scene.zoom_fit()
def canvas_zoom_fit(self_):
self_.scene.zoom_fit()

def canvas_zoom_in(self):
self.scene.zoom_in()
def canvas_zoom_in(self_):
self_.scene.zoom_in()

def canvas_zoom_out(self):
self.scene.zoom_out()
def canvas_zoom_out(self_):
self_.scene.zoom_out()

def canvas_zoom_reset(self):
self.scene.zoom_reset()
def canvas_zoom_reset(self_):
self_.scene.zoom_reset()

def canvas_print(self):
self.scene.clearSelection()
self.m_export_printer = QPrinter()
dialog = QPrintDialog(self.m_export_printer, self)
def canvas_print(self_):
self_.scene.clearSelection()
self_.m_export_printer = QPrinter()
dialog = QPrintDialog(self_.m_export_printer, self_)
if (dialog.exec_()):
painter = QPainter(self.m_export_printer)
painter = QPainter(self_.m_export_printer)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
self.scene.render(painter)
self_.scene.render(painter)

def canvas_save_image(self):
newPath = QFileDialog.getSaveFileName(self, self.tr("Save Image"), filter=self.tr("PNG Image (*.png);;JPEG Image (*.jpg)"))
def canvas_save_image(self_):
newPath = QFileDialog.getSaveFileName(self_, self_.tr("Save Image"), filter=self_.tr("PNG Image (*.png);;JPEG Image (*.jpg)"))
print(newPath)

if (newPath):
self.scene.clearSelection()
self_.scene.clearSelection()
if (newPath.endswith((".jpg", ".jpG", ".jPG", ".JPG", ".JPg", ".Jpg"))):
img_format = "JPG"
elif (newPath.endswith((".png", ".pnG", ".pNG", ".PNG", ".PNg", ".Png"))):
@@ -68,25 +68,25 @@ def canvas_save_image(self):
img_format = "PNG"
newPath += ".png"

self.m_export_image = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
painter = QPainter(self.m_export_image)
self_.m_export_image = QImage(self_.scene.sceneRect().width(), self_.scene.sceneRect().height(), QImage.Format_RGB32)
painter = QPainter(self_.m_export_image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
self.scene.render(painter)
self.m_export_image.save(newPath, img_format, 100)
self_.scene.render(painter)
self_.m_export_image.save(newPath, img_format, 100)

# Shared Connections
def setCanvasConnections(self):
self.act_canvas_arrange.setEnabled(False)
self.connect(self.act_canvas_arrange, SIGNAL("triggered()"), lambda: canvas_arrange(self))
self.connect(self.act_canvas_refresh, SIGNAL("triggered()"), lambda: canvas_refresh(self))
self.connect(self.act_canvas_zoom_fit, SIGNAL("triggered()"), lambda: canvas_zoom_fit(self))
self.connect(self.act_canvas_zoom_in, SIGNAL("triggered()"), lambda: canvas_zoom_in(self))
self.connect(self.act_canvas_zoom_out, SIGNAL("triggered()"), lambda: canvas_zoom_out(self))
self.connect(self.act_canvas_zoom_100, SIGNAL("triggered()"), lambda: canvas_zoom_reset(self))
self.connect(self.act_canvas_print, SIGNAL("triggered()"), lambda: canvas_print(self))
self.connect(self.act_canvas_save_image, SIGNAL("triggered()"), lambda: canvas_save_image(self))
self.connect(self.b_canvas_zoom_fit, SIGNAL("clicked()"), lambda: canvas_zoom_fit(self))
self.connect(self.b_canvas_zoom_in, SIGNAL("clicked()"), lambda: canvas_zoom_in(self))
self.connect(self.b_canvas_zoom_out, SIGNAL("clicked()"), lambda: canvas_zoom_out(self))
self.connect(self.b_canvas_zoom_100, SIGNAL("clicked()"), lambda: canvas_zoom_reset(self))
def setCanvasConnections(self_):
self_.act_canvas_arrange.setEnabled(False)
self_.connect(self_.act_canvas_arrange, SIGNAL("triggered()"), lambda: canvas_arrange())
self_.connect(self_.act_canvas_refresh, SIGNAL("triggered()"), lambda: canvas_refresh(self_))
self_.connect(self_.act_canvas_zoom_fit, SIGNAL("triggered()"), lambda: canvas_zoom_fit(self_))
self_.connect(self_.act_canvas_zoom_in, SIGNAL("triggered()"), lambda: canvas_zoom_in(self_))
self_.connect(self_.act_canvas_zoom_out, SIGNAL("triggered()"), lambda: canvas_zoom_out(self_))
self_.connect(self_.act_canvas_zoom_100, SIGNAL("triggered()"), lambda: canvas_zoom_reset(self_))
self_.connect(self_.act_canvas_print, SIGNAL("triggered()"), lambda: canvas_print(self_))
self_.connect(self_.act_canvas_save_image, SIGNAL("triggered()"), lambda: canvas_save_image(self_))
self_.connect(self_.b_canvas_zoom_fit, SIGNAL("clicked()"), lambda: canvas_zoom_fit(self_))
self_.connect(self_.b_canvas_zoom_in, SIGNAL("clicked()"), lambda: canvas_zoom_in(self_))
self_.connect(self_.b_canvas_zoom_out, SIGNAL("clicked()"), lambda: canvas_zoom_out(self_))
self_.connect(self_.b_canvas_zoom_100, SIGNAL("clicked()"), lambda: canvas_zoom_reset(self_))

+ 149
- 151
src/shared_jack.py View File

@@ -26,12 +26,9 @@ from shared import *
from jacklib_helpers import *

# Have JACK2 ?
try:
JACK2 = True
if (jacklib.JACK2):
version_str = str(jacklib.get_version_string(), encoding="ascii")
print("Using JACK2, version %s" % (version_str))
except:
JACK2 = False

# Can Render ?
for iPATH in PATH:
@@ -92,88 +89,88 @@ jack.client = None
# -------------------------------------------------------------
# Property change calls

def jack_buffer_size(self, buffer_size):
if (self.m_buffer_size != buffer_size):
def jack_buffer_size(self_, buffer_size):
if (self_.m_buffer_size != buffer_size):
if (jack.client):
failed = bool(jacklib.set_buffer_size(jack.client, buffer_size) != 0)
else:
failed = bool(jacksettings.setBufferSize(buffer_size))

if (failed):
print("Failed to change buffer-size as %i, reset to %i" % (buffer_size, self.m_buffer_size))
setBufferSize(self, self.m_buffer_size, True)
print("Failed to change buffer-size as %i, reset to %i" % (buffer_size, self_.m_buffer_size))
setBufferSize(self_, self_.m_buffer_size, True)

def jack_sample_rate(self, sample_rate):
def jack_sample_rate(self_, sample_rate):
if (jack.client):
setSampleRate(self, sample_rate, True)
setSampleRate(self_, sample_rate, True)
else:
if (jacksettings.setSampleRate(sample_rate)):
setSampleRate(self, sample_rate)
setSampleRate(self_, sample_rate)

@pyqtSlot(str)
def slot_jackBufferSize_ComboBox(self, text):
if (not text or text.isdigit() == False):
#@pyqtSlot(str)
def slot_jackBufferSize_ComboBox(self_, text):
if (not text or not text.isdigit()):
return
jack_buffer_size(self, int(text))
jack_buffer_size(self_, int(text))

@pyqtSlot(int)
def slot_jackBufferSize_Menu(self, buffer_size):
jack_buffer_size(self, buffer_size)
#@pyqtSlot(int)
def slot_jackBufferSize_Menu(self_, buffer_size):
jack_buffer_size(self_, buffer_size)

@pyqtSlot(str)
def slot_jackSampleRate_ComboBox(self, text):
if (not text or text.isdigit() == False):
#@pyqtSlot(str)
def slot_jackSampleRate_ComboBox(self_, text):
if (not text or not text.isdigit()):
return
jack_sample_rate(self, int(text))
jack_sample_rate(self_, int(text))

# -------------------------------------------------------------
# Transport calls

def setTransportView(self, view):
def setTransportView(self_, view):
if (view == TRANSPORT_VIEW_HMS):
self.m_selected_transport_view = TRANSPORT_VIEW_HMS
self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("00:00:00")+3)
self_.m_selected_transport_view = TRANSPORT_VIEW_HMS
self_.label_time.setMinimumWidth(QFontMetrics(self_.label_time.font()).width("00:00:00")+3)
elif (view == TRANSPORT_VIEW_BBT):
self.m_selected_transport_view = TRANSPORT_VIEW_BBT
self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000|00|0000")+3)
self_.m_selected_transport_view = TRANSPORT_VIEW_BBT
self_.label_time.setMinimumWidth(QFontMetrics(self_.label_time.font()).width("000|00|0000")+3)
elif (view == TRANSPORT_VIEW_FRAMES):
self.m_selected_transport_view = TRANSPORT_VIEW_FRAMES
self.label_time.setMinimumWidth(QFontMetrics(self.label_time.font()).width("000'000'000")+3)
self_.m_selected_transport_view = TRANSPORT_VIEW_FRAMES
self_.label_time.setMinimumWidth(QFontMetrics(self_.label_time.font()).width("000'000'000")+3)
else:
self.m_selected_transport_view = None
self_.m_selected_transport_view = None

@pyqtSlot(bool)
def slot_transportPlayPause(self, play):
#@pyqtSlot(bool)
def slot_transportPlayPause(self_, play):
if (not jack.client): return
if (play):
jacklib.transport_start(jack.client)
else:
jacklib.transport_stop(jack.client)
refreshTransport(self)
refreshTransport(self_)

@pyqtSlot()
def slot_transportStop(self):
#@pyqtSlot()
def slot_transportStop(self_):
if (not jack.client): return
jacklib.transport_stop(jack.client)
jacklib.transport_locate(jack.client, 0)
refreshTransport(self)
refreshTransport(self_)

@pyqtSlot()
def slot_transportBackwards(self):
#@pyqtSlot()
def slot_transportBackwards():
if (not jack.client): return
new_frame = jacklib.get_current_transport_frame(jack.client)-100000
if (new_frame < 0): new_frame = 0
jacklib.transport_locate(jack.client, new_frame)

@pyqtSlot()
def slot_transportForwards(self):
#@pyqtSlot()
def slot_transportForwards():
if (not jack.client): return
new_frame = jacklib.get_current_transport_frame(jack.client)+100000
jacklib.transport_locate(jack.client, new_frame)

@pyqtSlot()
def slot_transportViewMenu(self):
menu = QMenu(self)
#@pyqtSlot()
def slot_transportViewMenu(self_):
menu = QMenu(self_)
act_t_hms = menu.addAction("Hours:Minutes:Seconds")
act_t_bbt = menu.addAction("Beat:Bar:Tick")
act_t_fr = menu.addAction("Frames")
@@ -182,44 +179,44 @@ def slot_transportViewMenu(self):
act_t_bbt.setCheckable(True)
act_t_fr.setCheckable(True)

if (self.m_selected_transport_view == TRANSPORT_VIEW_HMS):
if (self_.m_selected_transport_view == TRANSPORT_VIEW_HMS):
act_t_hms.setChecked(True)
elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT):
elif (self_.m_selected_transport_view == TRANSPORT_VIEW_BBT):
act_t_bbt.setChecked(True)
elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
elif (self_.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
act_t_fr.setChecked(True)

act_selected = menu.exec_(QCursor().pos())

if (act_selected == act_t_hms):
setTransportView(self, TRANSPORT_VIEW_HMS)
setTransportView(self_, TRANSPORT_VIEW_HMS)
elif (act_selected == act_t_bbt):
setTransportView(self, TRANSPORT_VIEW_BBT)
setTransportView(self_, TRANSPORT_VIEW_BBT)
elif (act_selected == act_t_fr):
setTransportView(self, TRANSPORT_VIEW_FRAMES)
setTransportView(self_, TRANSPORT_VIEW_FRAMES)

# -------------------------------------------------------------
# Refresh GUI stuff

def refreshDSPLoad(self):
def refreshDSPLoad(self_):
if (not jack.client): return
setDSPLoad(self, int(jacklib.cpu_load(jack.client)))
setDSPLoad(self_, int(jacklib.cpu_load(jack.client)))

def refreshTransport(self):
def refreshTransport(self_):
if (not jack.client): return
pos = jacklib.jack_position_t()
pos.valid = 0
state = jacklib.transport_query(jack.client, jacklib.pointer(pos))

if (self.m_selected_transport_view == TRANSPORT_VIEW_HMS):
if (self_.m_selected_transport_view == TRANSPORT_VIEW_HMS):
frame = pos.frame
time = frame / self.m_sample_rate
time = frame / self_.m_sample_rate
secs = time % 60
mins = (time / 60) % 60
hrs = (time / 3600) % 60
self.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
self_.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))

elif (self.m_selected_transport_view == TRANSPORT_VIEW_BBT):
elif (self_.m_selected_transport_view == TRANSPORT_VIEW_BBT):
if (pos.valid & jacklib.JackPositionBBT):
bar = pos.bar
beat = pos.beat
@@ -227,83 +224,84 @@ def refreshTransport(self):
if (bar == 0):
beat = 0
tick = 0
self.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
self_.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
else:
self.label_time.setText("000|00|0000")
self_.label_time.setText("000|00|0000")

elif (self.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
elif (self_.m_selected_transport_view == TRANSPORT_VIEW_FRAMES):
frame = pos.frame
frame1 = pos.frame % 1000
frame2 = (pos.frame / 1000) % 1000
frame3 = (pos.frame / 1000000) % 1000
self.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))
self_.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))

if (pos.valid & jacklib.JackPositionBBT):
if (self.m_last_bpm != pos.beats_per_minute):
self.sb_bpm.setValue(pos.beats_per_minute)
self.sb_bpm.setStyleSheet("")
if (self_.m_last_bpm != pos.beats_per_minute):
self_.sb_bpm.setValue(pos.beats_per_minute)
self_.sb_bpm.setStyleSheet("")
else:
pos.beats_per_minute = -1
if (self.m_last_bpm != pos.beats_per_minute):
self.sb_bpm.setStyleSheet("QDoubleSpinBox { color: palette(mid); }")
if (self_.m_last_bpm != pos.beats_per_minute):
self_.sb_bpm.setStyleSheet("QDoubleSpinBox { color: palette(mid); }")

self.m_last_bpm = pos.beats_per_minute
self_.m_last_bpm = pos.beats_per_minute

if (state != self.m_last_transport_state):
if (state != self_.m_last_transport_state):
if (state == jacklib.JackTransportStopped):
icon = getIcon("media-playback-start")
self.act_transport_play.setChecked(False)
self.act_transport_play.setIcon(icon)
self.act_transport_play.setText(self.tr("&Play"))
self.b_transport_play.setChecked(False)
self.b_transport_play.setIcon(icon)
self_.act_transport_play.setChecked(False)
self_.act_transport_play.setIcon(icon)
self_.act_transport_play.setText(self_.tr("&Play"))
self_.b_transport_play.setChecked(False)
self_.b_transport_play.setIcon(icon)
else:
icon = getIcon("media-playback-pause")
self.act_transport_play.setChecked(True)
self.act_transport_play.setIcon(icon)
self.act_transport_play.setText(self.tr("&Pause"))
self.b_transport_play.setChecked(True)
self.b_transport_play.setIcon(icon)
self.m_last_transport_state = state
self_.act_transport_play.setChecked(True)
self_.act_transport_play.setIcon(icon)
self_.act_transport_play.setText(self_.tr("&Pause"))
self_.b_transport_play.setChecked(True)
self_.b_transport_play.setIcon(icon)

self_.m_last_transport_state = state

# -------------------------------------------------------------
# Set GUI stuff

def setBufferSize(self, buffer_size, forced=False):
if (self.m_buffer_size == buffer_size and not forced):
def setBufferSize(self_, buffer_size, forced=False):
if (self_.m_buffer_size == buffer_size and not forced):
return

self.m_buffer_size = buffer_size
self_.m_buffer_size = buffer_size
if (buffer_size):
if (buffer_size == 16):
self.cb_buffer_size.setCurrentIndex(0)
self_.cb_buffer_size.setCurrentIndex(0)
elif (buffer_size == 32):
self.cb_buffer_size.setCurrentIndex(1)
self_.cb_buffer_size.setCurrentIndex(1)
elif (buffer_size == 64):
self.cb_buffer_size.setCurrentIndex(2)
self_.cb_buffer_size.setCurrentIndex(2)
elif (buffer_size == 128):
self.cb_buffer_size.setCurrentIndex(3)
self_.cb_buffer_size.setCurrentIndex(3)
elif (buffer_size == 256):
self.cb_buffer_size.setCurrentIndex(4)
self_.cb_buffer_size.setCurrentIndex(4)
elif (buffer_size == 512):
self.cb_buffer_size.setCurrentIndex(5)
self_.cb_buffer_size.setCurrentIndex(5)
elif (buffer_size == 1024):
self.cb_buffer_size.setCurrentIndex(6)
self_.cb_buffer_size.setCurrentIndex(6)
elif (buffer_size == 2048):
self.cb_buffer_size.setCurrentIndex(7)
self_.cb_buffer_size.setCurrentIndex(7)
elif (buffer_size == 4096):
self.cb_buffer_size.setCurrentIndex(8)
self_.cb_buffer_size.setCurrentIndex(8)
elif (buffer_size == 8192):
self.cb_buffer_size.setCurrentIndex(9)
self_.cb_buffer_size.setCurrentIndex(9)
else:
QMessageBox.warning(self, self.tr("Warning"), self.tr("Invalid JACK buffer-size requested: %i" % (buffer_size)))
QMessageBox.warning(self_, self_.tr("Warning"), self_.tr("Invalid JACK buffer-size requested: %i" % (buffer_size)))

if ("act_jack_bf_list" in dir(self)):
if ("act_jack_bf_list" in dir(self_)):
if (buffer_size):
for act_bf in self.act_jack_bf_list:
for act_bf in self_.act_jack_bf_list:
act_bf.setEnabled(True)
if (act_bf.text().replace("&","") == str(buffer_size)):
if (act_bf.isChecked() == False):
if (not act_bf.isChecked()):
act_bf.setChecked(True)
else:
if (act_bf.isChecked()):
@@ -314,104 +312,104 @@ def setBufferSize(self, buffer_size, forced=False):
#if (self.act_jack_bf_list[i].isChecked()):
#self.act_jack_bf_list[i].setChecked(False)

def setSampleRate(self, sample_rate, future=False):
if (self.m_sample_rate == sample_rate):
def setSampleRate(self_, sample_rate, future=False):
if (self_.m_sample_rate == sample_rate):
return

if (future):
pass
if (self.sender() == self.cb_sample_rate): # Changed using GUI
ask = QMessageBox.question(self, self.tr("Change Sample Rate"), self.tr("It's not possible to change Sample Rate while JACK is running.\n"
if (self_.sender() == self_.cb_sample_rate): # Changed using GUI
ask = QMessageBox.question(self_, self_.tr("Change Sample Rate"), self_.tr("It's not possible to change Sample Rate while JACK is running.\n"
"Do you want to change as soon as JACK stops?"), QMessageBox.Ok|QMessageBox.Cancel)
if (ask == QMessageBox.Ok):
self.m_next_sample_rate = sample_rate
self_.m_next_sample_rate = sample_rate
else:
self.m_next_sample_rate = 0
self_.m_next_sample_rate = 0

# not future
else:
self.m_sample_rate = sample_rate
self.m_next_sample_rate = 0
self_.m_sample_rate = sample_rate
self_.m_next_sample_rate = 0

for i in range(len(sample_rates)):
sample_rate = sample_rates[i]
sample_rate_str = str(sample_rate)

self.cb_sample_rate.setItemText(i, sample_rate_str)
self_.cb_sample_rate.setItemText(i, sample_rate_str)

if (self.m_sample_rate == sample_rate):
self.cb_sample_rate.setCurrentIndex(i)
if (self_.m_sample_rate == sample_rate):
self_.cb_sample_rate.setCurrentIndex(i)

def setRealTime(self, realtime):
self.label_realtime.setText(" RT " if realtime else " <s>RT</s> ")
self.label_realtime.setEnabled(realtime)
def setRealTime(self_, realtime):
self_.label_realtime.setText(" RT " if realtime else " <s>RT</s> ")
self_.label_realtime.setEnabled(realtime)

def setDSPLoad(self, dsp_load):
self.pb_dsp_load.setValue(dsp_load)
def setDSPLoad(self_, dsp_load):
self_.pb_dsp_load.setValue(dsp_load)

def setXruns(self, xruns):
self.b_xruns.setText("%s Xrun%s" % (str(xruns) if (xruns >= 0) else "--", "" if (xruns == 1) else "s"))
def setXruns(self_, xruns):
self_.b_xruns.setText("%s Xrun%s" % (str(xruns) if (xruns >= 0) else "--", "" if (xruns == 1) else "s"))

# -------------------------------------------------------------
# External Dialogs

@pyqtSlot()
def slot_showJackSettings(self):
jacksettings.JackSettingsW(self).exec_()
def slot_showJackSettings(self_):
jacksettings.JackSettingsW(self_).exec_()

if (not jack.client):
# Force update of gui widgets
self.jackStopped()
self_.jackStopped()

@pyqtSlot()
def slot_showLogs(self):
logs.LogsW(self).show()
def slot_showLogs(self_):
logs.LogsW(self_).show()

@pyqtSlot()
def slot_showRender(self):
render.RenderW(self).exec_()
def slot_showRender(self_):
render.RenderW(self_).exec_()

# -------------------------------------------------------------
# Shared Connections

def setJackConnections(self, modes):
def setJackConnections(self_, modes):
pass
if ("jack" in modes):
self.connect(self.act_jack_clear_xruns, SIGNAL("triggered()"), SLOT("slot_JackClearXruns()"))
self.connect(self.act_jack_render, SIGNAL("triggered()"), lambda: slot_showRender(self))
self.connect(self.act_jack_configure, SIGNAL("triggered()"), lambda: slot_showJackSettings(self))
self.connect(self.b_jack_clear_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
self.connect(self.b_jack_configure, SIGNAL("clicked()"), lambda: slot_showJackSettings(self))
self.connect(self.b_jack_render, SIGNAL("clicked()"), lambda: slot_showRender(self))
self.connect(self.cb_buffer_size, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackBufferSize_ComboBox(self, self.cb_buffer_size.currentText()))
self.connect(self.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackSampleRate_ComboBox(self, self.cb_sample_rate.currentText()))
self.connect(self.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
self_.connect(self_.act_jack_clear_xruns, SIGNAL("triggered()"), SLOT("slot_JackClearXruns()"))
self_.connect(self_.act_jack_render, SIGNAL("triggered()"), lambda: slot_showRender(self_))
self_.connect(self_.act_jack_configure, SIGNAL("triggered()"), lambda: slot_showJackSettings(self_))
self_.connect(self_.b_jack_clear_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))
self_.connect(self_.b_jack_configure, SIGNAL("clicked()"), lambda: slot_showJackSettings(self_))
self_.connect(self_.b_jack_render, SIGNAL("clicked()"), lambda: slot_showRender(self_))
self_.connect(self_.cb_buffer_size, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackBufferSize_ComboBox(self_, self_.cb_buffer_size.currentText()))
self_.connect(self_.cb_sample_rate, SIGNAL("currentIndexChanged(QString)"), lambda: slot_jackSampleRate_ComboBox(self_, self_.cb_sample_rate.currentText()))
self_.connect(self_.b_xruns, SIGNAL("clicked()"), SLOT("slot_JackClearXruns()"))

if ("buffer-size" in modes):
self.connect(self.act_jack_bf_16, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 16))
self.connect(self.act_jack_bf_32, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 32))
self.connect(self.act_jack_bf_64, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 64))
self.connect(self.act_jack_bf_128, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 128))
self.connect(self.act_jack_bf_256, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 256))
self.connect(self.act_jack_bf_512, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 512))
self.connect(self.act_jack_bf_1024, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 1024))
self.connect(self.act_jack_bf_2048, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 2048))
self.connect(self.act_jack_bf_4096, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 4096))
self.connect(self.act_jack_bf_8192, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self, 8192))
self_.connect(self_.act_jack_bf_16, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 16))
self_.connect(self_.act_jack_bf_32, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 32))
self_.connect(self_.act_jack_bf_64, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 64))
self_.connect(self_.act_jack_bf_128, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 128))
self_.connect(self_.act_jack_bf_256, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 256))
self_.connect(self_.act_jack_bf_512, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 512))
self_.connect(self_.act_jack_bf_1024, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 1024))
self_.connect(self_.act_jack_bf_2048, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 2048))
self_.connect(self_.act_jack_bf_4096, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 4096))
self_.connect(self_.act_jack_bf_8192, SIGNAL("triggered(bool)"), lambda: slot_jackBufferSize_Menu(self_, 8192))

if ("transport" in modes):
self.connect(self.act_transport_play, SIGNAL("triggered(bool)"), lambda: slot_transportPlayPause(self, self.act_transport_play.isChecked()))
self.connect(self.act_transport_stop, SIGNAL("triggered()"), lambda: slot_transportStop(self))
self.connect(self.act_transport_backwards, SIGNAL("triggered()"), lambda: slot_transportBackwards(self))
self.connect(self.act_transport_forwards, SIGNAL("triggered()"), lambda: slot_transportForwards(self))
self.connect(self.b_transport_play, SIGNAL("clicked(bool)"), lambda: slot_transportPlayPause(self, self.b_transport_play.isChecked()))
self.connect(self.b_transport_stop, SIGNAL("clicked()"), lambda: slot_transportStop(self))
self.connect(self.b_transport_backwards, SIGNAL("clicked()"), lambda: slot_transportBackwards(self))
self.connect(self.b_transport_forwards, SIGNAL("clicked()"), lambda: slot_transportForwards(self))
self.connect(self.label_time, SIGNAL("customContextMenuRequested(QPoint)"), lambda: slot_transportViewMenu(self))
self_.connect(self_.act_transport_play, SIGNAL("triggered(bool)"), lambda: slot_transportPlayPause(self_, self_.act_transport_play.isChecked()))
self_.connect(self_.act_transport_stop, SIGNAL("triggered()"), lambda: slot_transportStop(self_))
self_.connect(self_.act_transport_backwards, SIGNAL("triggered()"), lambda: slot_transportBackwards())
self_.connect(self_.act_transport_forwards, SIGNAL("triggered()"), lambda: slot_transportForwards())
self_.connect(self_.b_transport_play, SIGNAL("clicked(bool)"), lambda: slot_transportPlayPause(self_, self_.b_transport_play.isChecked()))
self_.connect(self_.b_transport_stop, SIGNAL("clicked()"), lambda: slot_transportStop(self_))
self_.connect(self_.b_transport_backwards, SIGNAL("clicked()"), lambda: slot_transportBackwards())
self_.connect(self_.b_transport_forwards, SIGNAL("clicked()"), lambda: slot_transportForwards())
self_.connect(self_.label_time, SIGNAL("customContextMenuRequested(QPoint)"), lambda: slot_transportViewMenu(self_))

if ("misc" in modes):
if (LINUX):
self.connect(self.act_show_logs, SIGNAL("triggered()"), lambda: slot_showLogs(self))
self_.connect(self_.act_show_logs, SIGNAL("triggered()"), lambda: slot_showLogs(self_))
else:
self.act_show_logs.setEnabled(False)
self_.act_show_logs.setEnabled(False)

+ 2
- 2
src/shared_settings.py View File

@@ -52,7 +52,7 @@ def setDefaultProjectFolder(folder):

# Settings Dialog
class SettingsW(QDialog, ui_settings_app.Ui_SettingsW):
def __init__(self, parent, appName, hasGL):
def __init__(self, parent, appName, hasOpenGL):
QDialog.__init__(self, parent)
self.setupUi(self)

@@ -84,7 +84,7 @@ class SettingsW(QDialog, ui_settings_app.Ui_SettingsW):
self.settings = self.parent().settings
self.loadSettings()

if not hasGL:
if (not hasOpenGL):
self.cb_canvas_use_opengl.setChecked(False)
self.cb_canvas_use_opengl.setEnabled(False)



+ 32
- 0
src/ui/claudia.ui View File

@@ -1416,5 +1416,37 @@
</hint>
</hints>
</connection>
<connection>
<sender>act_settings_show_toolbar</sender>
<signal>triggered(bool)</signal>
<receiver>frame_toolbar</receiver>
<slot>setEnabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>438</x>
<y>52</y>
</hint>
</hints>
</connection>
<connection>
<sender>act_settings_show_statusbar</sender>
<signal>triggered(bool)</signal>
<receiver>frame_statusbar</receiver>
<slot>setEnabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>438</x>
<y>546</y>
</hint>
</hints>
</connection>
</connections>
</ui>

+ 1
- 1
src/xycontroller.py View File

@@ -591,7 +591,7 @@ if __name__ == '__main__':

# Start jack
jack_status = jacklib.jack_status_t(0)
jack_client = jacklib.client_open_uuid("XY-Controller", jacklib.JackSessionID, jacklib.pointer(jack_status), "")
jack_client = jacklib.client_open("XY-Controller", jacklib.JackSessionID, jacklib.pointer(jack_status))

if not jack_client:
QMessageBox.critical(None, app.translate("XYControllerW", "Error"), app.translate("XYControllerW", "Could not connect to JACK, possible errors:\n%s" % (get_jack_status_error_string(jack_status))))


Write Preview
Loading…
Cancel
Save