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

Update Catia code

tags/v0.9.0
falkTX 12 years ago
parent
d208886199
commit
4715596b45
3 changed files with 600 additions and 581 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +356
    -345
      src/catia.py
  2. +27
    -28
      src/shared.py
  3. +217
    -208
      src/shared_canvasjack.py

+ 356
- 345
src/catia.py
File diff suppressed because it is too large
View File


+ 27
- 28
src/shared.py View File

@@ -262,38 +262,37 @@ def setIcons(self_, modes):
if gGui is None:
gGui = self_

# TODO - need to update Catia and Claudia code first
if "canvas" in modes:
gGui.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
gGui.act_canvas_refresh.setIcon(getIcon("view-refresh"))
gGui.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
gGui.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
gGui.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
gGui.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
gGui.act_canvas_print.setIcon(getIcon("document-print"))
gGui.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
gGui.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
gGui.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
gGui.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))
gGui.ui.act_canvas_arrange.setIcon(getIcon("view-sort-ascending"))
gGui.ui.act_canvas_refresh.setIcon(getIcon("view-refresh"))
gGui.ui.act_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
gGui.ui.act_canvas_zoom_in.setIcon(getIcon("zoom-in"))
gGui.ui.act_canvas_zoom_out.setIcon(getIcon("zoom-out"))
gGui.ui.act_canvas_zoom_100.setIcon(getIcon("zoom-original"))
gGui.ui.act_canvas_print.setIcon(getIcon("document-print"))
gGui.ui.b_canvas_zoom_fit.setIcon(getIcon("zoom-fit-best"))
gGui.ui.b_canvas_zoom_in.setIcon(getIcon("zoom-in"))
gGui.ui.b_canvas_zoom_out.setIcon(getIcon("zoom-out"))
gGui.ui.b_canvas_zoom_100.setIcon(getIcon("zoom-original"))

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

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

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

+ 217
- 208
src/shared_canvasjack.py View File

@@ -19,7 +19,7 @@
# ------------------------------------------------------------------------------------------------------------
# Imports (Global)

from PyQt4.QtCore import pyqtSlot, QSettings, QTimer
from PyQt4.QtCore import pyqtSlot, QTimer
from PyQt4.QtGui import QCursor, QFontMetrics, QImage, QMainWindow, QMenu, QPainter, QPrinter, QPrintDialog

# ------------------------------------------------------------------------------------------------------------
@@ -67,18 +67,18 @@ class DBusObject(object):
'patchbay'
]

DBus = DBusObject()
DBus.loop = None
DBus.bus = None
DBus.a2j = None
DBus.jack = None
DBus.ladish_control = None
DBus.ladish_studio = None
DBus.ladish_room = None
DBus.ladish_graph = None
DBus.ladish_app_iface = None
DBus.ladish_app_daemon = None
DBus.patchbay = None
gDBus = DBusObject()
gDBus.loop = None
gDBus.bus = None
gDBus.a2j = None
gDBus.jack = None
gDBus.ladish_control = None
gDBus.ladish_studio = None
gDBus.ladish_room = None
gDBus.ladish_graph = None
gDBus.ladish_app_iface = None
gDBus.ladish_app_daemon = None
gDBus.patchbay = None

# ------------------------------------------------------------------------------------------------------------
# Global JACK object
@@ -88,8 +88,8 @@ class JackObject(object):
'client'
]

jack = JackObject()
jack.client = None
gJack = JackObject()
gJack.client = None

# ------------------------------------------------------------------------------------------------------------
# Abstract Canvas and JACK Class
@@ -98,50 +98,49 @@ class AbstractCanvasJackClass(QMainWindow):
def __init__(self, parent, appName):
QMainWindow.__init__(self, parent)

self.m_appName = appName
self.m_curTransportView = TRANSPORT_VIEW_HMS
self.fAppName = appName
self.fCurTransportView = TRANSPORT_VIEW_HMS

self.m_lastBPM = None
self.m_lastTransportState = None
self.fLastBPM = None
self.fLastTransportState = None

self.m_xruns = -1
self.m_bufferSize = 0
self.m_sampleRate = 0
self.m_nextSampleRate = 0
self.fXruns = -1
self.fBufferSize = 0
self.fSampleRate = 0.0
self.fNextSampleRate = 0.0

self.m_logsW = None

self.settings = QSettings("Cadence", appName)
self.fLogsW = None

# -----------------------------------------------------------------
# JACK Property change calls

def jack_setBufferSize(self, bufferSize):
if self.m_bufferSize == bufferSize:
if self.fBufferSize == bufferSize:
return

if jack.client:
failed = bool(jacklib.set_buffer_size(jack.client, bufferSize) != 0)
if gJack.client:
failed = bool(jacklib.set_buffer_size(gJack.client, bufferSize) != 0)
else:
failed = bool(jacksettings.setBufferSize(bufferSize))

if failed:
print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.m_bufferSize))
self.setBufferSize(self.m_bufferSize, True)
print("Failed to change buffer-size as %i, reset to %i" % (bufferSize, self.fBufferSize))
self.ui_setBufferSize(self.fBufferSize, True)

def jack_setSampleRate(self, sampleRate):
if jack.client:
if gJack.client:
# Show change-in-future dialog
self.setSampleRate(sampleRate, True)
self.ui_setSampleRate(sampleRate, True)
else:
# Try to set sampleRate via dbus now
if jacksettings.setSampleRate(sampleRate):
self.setSampleRate(sampleRate)
self.ui_setSampleRate(sampleRate)

@pyqtSlot()
def slot_jackBufferSize_Menu(self):
bufferSize = int(self.sender().text())
self.jack_setBufferSize(bufferSize)
text = self.sender().text()
if text and text.isdigit():
self.jack_setBufferSize(int(text))

@pyqtSlot(str)
def slot_jackBufferSize_ComboBox(self, text):
@@ -158,225 +157,234 @@ class AbstractCanvasJackClass(QMainWindow):

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

@pyqtSlot(bool)
def slot_transportPlayPause(self, play):
if not jack.client: return
if not gJack.client:
return

if play:
jacklib.transport_start(jack.client)
jacklib.transport_start(gJack.client)
else:
jacklib.transport_stop(jack.client)
jacklib.transport_stop(gJack.client)

self.refreshTransport()

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

jacklib.transport_stop(gJack.client)
jacklib.transport_locate(gJack.client, 0)

self.refreshTransport()

@pyqtSlot()
def slot_transportBackwards(self):
if not jack.client: return
newFrame = jacklib.get_current_transport_frame(jack.client) - 100000
if not gJack.client:
return

newFrame = jacklib.get_current_transport_frame(gJack.client) - 100000

if newFrame < 0:
newFrame = 0
jacklib.transport_locate(jack.client, newFrame)

jacklib.transport_locate(gJack.client, newFrame)

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

newFrame = jacklib.get_current_transport_frame(gJack.client) + 100000
jacklib.transport_locate(gJack.client, newFrame)

@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")
actHMS = menu.addAction("Hours:Minutes:Seconds")
actBBT = menu.addAction("Beat:Bar:Tick")
actFrames = menu.addAction("Frames")

act_t_hms.setCheckable(True)
act_t_bbt.setCheckable(True)
act_t_fr.setCheckable(True)
actHMS.setCheckable(True)
actBBT.setCheckable(True)
actFrames.setCheckable(True)

if self.m_curTransportView == TRANSPORT_VIEW_HMS:
act_t_hms.setChecked(True)
elif self.m_curTransportView == TRANSPORT_VIEW_BBT:
act_t_bbt.setChecked(True)
elif self.m_curTransportView == TRANSPORT_VIEW_FRAMES:
act_t_fr.setChecked(True)
if self.fCurTransportView == TRANSPORT_VIEW_HMS:
actHMS.setChecked(True)
elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
actBBT.setChecked(True)
elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
actFrames.setChecked(True)

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

if act_selected == act_t_hms:
if actSelected == actHMS:
self.setTransportView(TRANSPORT_VIEW_HMS)
elif act_selected == act_t_bbt:
elif actSelected == actBBT:
self.setTransportView(TRANSPORT_VIEW_BBT)
elif act_selected == act_t_fr:
elif actSelected == actFrames:
self.setTransportView(TRANSPORT_VIEW_FRAMES)

# -----------------------------------------------------------------
# Refresh JACK stuff

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

self.ui_setDSPLoad(int(jacklib.cpu_load(gJack.client)))

def refreshTransport(self):
if not jack.client: return
if not gJack.client:
return

pos = jacklib.jack_position_t()
pos.valid = 0
state = jacklib.transport_query(jack.client, jacklib.pointer(pos))

if self.m_curTransportView == TRANSPORT_VIEW_HMS:
time = pos.frame / self.m_sampleRate
state = jacklib.transport_query(gJack.client, jacklib.pointer(pos))

if self.fCurTransportView == TRANSPORT_VIEW_HMS:
time = pos.frame / int(self.fSampleRate)
secs = time % 60
mins = (time / 60) % 60
hrs = (time / 3600) % 60
self.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))
self.ui.label_time.setText("%02i:%02i:%02i" % (hrs, mins, secs))

elif self.m_curTransportView == TRANSPORT_VIEW_BBT:
elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
if pos.valid & jacklib.JackPositionBBT:
bar = pos.bar
beat = pos.beat if bar != 0 else 0
tick = pos.tick if bar != 0 else 0
self.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
self.ui.label_time.setText("%03i|%02i|%04i" % (bar, beat, tick))
else:
self.label_time.setText("%03i|%02i|%04i" % (0, 0, 0))
self.ui.label_time.setText("%03i|%02i|%04i" % (0, 0, 0))

elif self.m_curTransportView == TRANSPORT_VIEW_FRAMES:
elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
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.ui.label_time.setText("%03i'%03i'%03i" % (frame3, frame2, frame1))

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

self.fLastBPM = pos.beats_per_minute

self.m_lastBPM = pos.beats_per_minute
if state != self.fLastTransportState:
self.fLastTransportState = state

if state != self.m_lastTransportState:
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.ui.act_transport_play.setChecked(False)
self.ui.act_transport_play.setIcon(icon)
self.ui.act_transport_play.setText(self.tr("&Play"))
self.ui.b_transport_play.setChecked(False)
self.ui.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_lastTransportState = state
self.ui.act_transport_play.setChecked(True)
self.ui.act_transport_play.setIcon(icon)
self.ui.act_transport_play.setText(self.tr("&Pause"))
self.ui.b_transport_play.setChecked(True)
self.ui.b_transport_play.setIcon(icon)

# -----------------------------------------------------------------
# Set JACK stuff

def setBufferSize(self, bufferSize, forced=False):
if self.m_bufferSize == bufferSize and not forced:
def ui_setBufferSize(self, bufferSize, forced=False):
if self.fBufferSize == bufferSize and not forced:
return

self.m_bufferSize = bufferSize
self.fBufferSize = bufferSize

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

if self.m_appName == "Catia":
if bufferSize:
for act_bf in self.act_jack_bf_list:
act_bf.setEnabled(True)
if act_bf.text().replace("&", "") == str(bufferSize):
if not act_bf.isChecked():
act_bf.setChecked(True)
else:
if act_bf.isChecked():
act_bf.setChecked(False)
#else:
#for act_bf in self.act_jack_bf_list:
#act_bf.setEnabled(False)
#if act_bf.isChecked():
#act_bf.setChecked(False)

def setSampleRate(self, sampleRate, future=False):
if self.m_sampleRate == sampleRate:
self.ui.cb_buffer_size.setCurrentIndex(-1)

if self.fAppName == "Catia" and bufferSize:
for actBufSize in self.ui.act_jack_bf_list:
actBufSize.setEnabled(True)

if actBufSize.text().replace("&", "") == str(bufferSize):
if not actBufSize.isChecked():
actBufSize.setChecked(True)
elif actBufSize.isChecked():
actBufSize.setChecked(False)

def ui_setSampleRate(self, sampleRate, future=False):
if self.fSampleRate == sampleRate:
return

if future:
#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_nextSampleRate = sampleRate
else:
self.m_nextSampleRate = 0
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.fNextSampleRate = sampleRate
else:
self.fNextSampleRate = 0.0

# not future
else:
self.m_sampleRate = sampleRate
self.m_nextSampleRate = 0
self.fSampleRate = sampleRate
self.fNextSampleRate = 0.0

for i in range(len(SAMPLE_RATE_LIST)):
sampleRate = SAMPLE_RATE_LIST[i]
#sampleRateStr = str(sampleRate)
#self.cb_sample_rate.setItemText(i, sampleRateStr)

if self.m_sampleRate == sampleRate:
self.cb_sample_rate.setCurrentIndex(i)
if self.fSampleRate == sampleRate:
self.ui.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 ui_setRealTime(self, isRealtime):
self.ui.label_realtime.setText(" RT " if isRealtime else " <s>RT</s> ")
self.ui.label_realtime.setEnabled(isRealtime)

def setDSPLoad(self, dsp_load):
self.pb_dsp_load.setValue(dsp_load)
def ui_setDSPLoad(self, dspLoad):
self.ui.pb_dsp_load.setValue(dspLoad)

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

# -----------------------------------------------------------------
# External Dialogs
@@ -388,14 +396,14 @@ class AbstractCanvasJackClass(QMainWindow):
del jacksettingsW

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

@pyqtSlot()
def slot_showLogs(self):
if self.m_logsW is None:
self.m_logsW = logs.LogsW(self)
self.m_logsW.show()
if self.fLogsW is None:
self.fLogsW = logs.LogsW(self)
self.fLogsW.show()

@pyqtSlot()
def slot_showRender(self):
@@ -434,11 +442,11 @@ class AbstractCanvasJackClass(QMainWindow):
@pyqtSlot()
def slot_canvasPrint(self):
self.scene.clearSelection()
self.m_exportPrinter = QPrinter()
dialog = QPrintDialog(self.m_exportPrinter, self)
self.fExportPrinter = QPrinter()
dialog = QPrintDialog(self.fExportPrinter, self)

if dialog.exec_():
painter = QPainter(self.m_exportPrinter)
painter = QPainter(self.fExportPrinter)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
self.scene.render(painter)
@@ -450,6 +458,7 @@ class AbstractCanvasJackClass(QMainWindow):
if newPath:
self.scene.clearSelection()

# FIXME - must be a better way...
if newPath.endswith((".jpg", ".jpG", ".jPG", ".JPG", ".JPg", ".Jpg")):
imgFormat = "JPG"
elif newPath.endswith((".png", ".pnG", ".pNG", ".PNG", ".PNg", ".Png")):
@@ -459,68 +468,68 @@ class AbstractCanvasJackClass(QMainWindow):
imgFormat = "PNG"
newPath += ".png"

self.m_exportImage = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
painter = QPainter(self.m_exportImage)
self.fExportImage = QImage(self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32)
painter = QPainter(self.fExportImage)
painter.setRenderHint(QPainter.Antialiasing) # TODO - set true, cleanup this
painter.setRenderHint(QPainter.TextAntialiasing)
self.scene.render(painter)
self.m_exportImage.save(newPath, imgFormat, 100)
self.fExportImage.save(newPath, imgFormat, 100)

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

def setCanvasConnections(self):
self.act_canvas_arrange.setEnabled(False) # TODO, later
self.connect(self.act_canvas_arrange, SIGNAL("triggered()"), SLOT("slot_canvasArrange()"))
self.connect(self.act_canvas_refresh, SIGNAL("triggered()"), SLOT("slot_canvasRefresh()"))
self.connect(self.act_canvas_zoom_fit, SIGNAL("triggered()"), SLOT("slot_canvasZoomFit()"))
self.connect(self.act_canvas_zoom_in, SIGNAL("triggered()"), SLOT("slot_canvasZoomIn()"))
self.connect(self.act_canvas_zoom_out, SIGNAL("triggered()"), SLOT("slot_canvasZoomOut()"))
self.connect(self.act_canvas_zoom_100, SIGNAL("triggered()"), SLOT("slot_canvasZoomReset()"))
self.connect(self.act_canvas_print, SIGNAL("triggered()"), SLOT("slot_canvasPrint()"))
self.connect(self.act_canvas_save_image, SIGNAL("triggered()"), SLOT("slot_canvasSaveImage()"))
self.connect(self.b_canvas_zoom_fit, SIGNAL("clicked()"), SLOT("slot_canvasZoomFit()"))
self.connect(self.b_canvas_zoom_in, SIGNAL("clicked()"), SLOT("slot_canvasZoomIn()"))
self.connect(self.b_canvas_zoom_out, SIGNAL("clicked()"), SLOT("slot_canvasZoomOut()"))
self.connect(self.b_canvas_zoom_100, SIGNAL("clicked()"), SLOT("slot_canvasZoomReset()"))
self.ui.act_canvas_arrange.setEnabled(False) # TODO, later
self.connect(self.ui.act_canvas_arrange, SIGNAL("triggered()"), SLOT("slot_canvasArrange()"))
self.connect(self.ui.act_canvas_refresh, SIGNAL("triggered()"), SLOT("slot_canvasRefresh()"))
self.connect(self.ui.act_canvas_zoom_fit, SIGNAL("triggered()"), SLOT("slot_canvasZoomFit()"))
self.connect(self.ui.act_canvas_zoom_in, SIGNAL("triggered()"), SLOT("slot_canvasZoomIn()"))
self.connect(self.ui.act_canvas_zoom_out, SIGNAL("triggered()"), SLOT("slot_canvasZoomOut()"))
self.connect(self.ui.act_canvas_zoom_100, SIGNAL("triggered()"), SLOT("slot_canvasZoomReset()"))
self.connect(self.ui.act_canvas_print, SIGNAL("triggered()"), SLOT("slot_canvasPrint()"))
self.connect(self.ui.act_canvas_save_image, SIGNAL("triggered()"), SLOT("slot_canvasSaveImage()"))
self.connect(self.ui.b_canvas_zoom_fit, SIGNAL("clicked()"), SLOT("slot_canvasZoomFit()"))
self.connect(self.ui.b_canvas_zoom_in, SIGNAL("clicked()"), SLOT("slot_canvasZoomIn()"))
self.connect(self.ui.b_canvas_zoom_out, SIGNAL("clicked()"), SLOT("slot_canvasZoomOut()"))
self.connect(self.ui.b_canvas_zoom_100, SIGNAL("clicked()"), SLOT("slot_canvasZoomReset()"))

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

if "buffer-size" in modes:
self.connect(self.act_jack_bf_16, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_32, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_64, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_128, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_256, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_512, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_1024, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_2048, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_4096, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.act_jack_bf_8192, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_16, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_32, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_64, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_128, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_256, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_512, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_1024, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_2048, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_4096, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))
self.connect(self.ui.act_jack_bf_8192, SIGNAL("triggered(bool)"), SLOT("slot_jackBufferSize_Menu()"))

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

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

Write Preview
Loading…
Cancel
Save