Carla/source/carla

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Carla plugin host
# Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of
# the License, or any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# For a full copy of the GNU General Public License see the GPL.txt file

# ------------------------------------------------------------------------------------------------------------
# Imports (Global)

from PyQt4.QtGui import QLabel, QTabWidget

# ------------------------------------------------------------------------------------------------------------
# Imports (Custom Stuff)

from carla_host import *
from carla_patchbay import CarlaPatchbayW
from carla_rack import CarlaRackW

# ------------------------------------------------------------------------------------------------------------
# Tab widget (rack + patchbay)

class CarlaMultiW(QTabWidget):
    def __init__(self, parent):
        QTabWidget.__init__(self, parent)

        self.fRack     = CarlaRackW(parent, False)
        self.fPatchbay = CarlaPatchbayW(parent, False, False)
        self.fParent   = parent
        self.fUseCustomPaint = False

        self.addTab(self.fRack, "Plugins")
        self.addTab(self.fPatchbay, "Patchbay")

        self.scene = self.fPatchbay.scene

        parent.ui.act_plugins_enable.triggered.connect(self.fRack.slot_pluginsEnable)
        parent.ui.act_plugins_disable.triggered.connect(self.fRack.slot_pluginsDisable)
        parent.ui.act_plugins_volume100.triggered.connect(self.fRack.slot_pluginsVolume100)
        parent.ui.act_plugins_mute.triggered.connect(self.fRack.slot_pluginsMute)
        parent.ui.act_plugins_wet100.triggered.connect(self.fRack.slot_pluginsWet100)
        parent.ui.act_plugins_bypass.triggered.connect(self.fRack.slot_pluginsBypass)
        parent.ui.act_plugins_center.triggered.connect(self.fRack.slot_pluginsCenter)
        parent.ui.act_plugins_panic.triggered.connect(self.fRack.slot_pluginsDisable)

        parent.ui.act_canvas_arrange.setEnabled(False) # TODO, later
        parent.ui.act_canvas_arrange.triggered.connect(self.fPatchbay.slot_canvasArrange)
        parent.ui.act_canvas_refresh.triggered.connect(self.fPatchbay.slot_canvasRefresh)
        parent.ui.act_canvas_zoom_fit.triggered.connect(self.fPatchbay.slot_canvasZoomFit)
        parent.ui.act_canvas_zoom_in.triggered.connect(self.fPatchbay.slot_canvasZoomIn)
        parent.ui.act_canvas_zoom_out.triggered.connect(self.fPatchbay.slot_canvasZoomOut)
        parent.ui.act_canvas_zoom_100.triggered.connect(self.fPatchbay.slot_canvasZoomReset)
        parent.ui.act_canvas_print.triggered.connect(self.fPatchbay.slot_canvasPrint)
        parent.ui.act_canvas_save_image.triggered.connect(self.fPatchbay.slot_canvasSaveImage)

        parent.ui.act_settings_configure.triggered.connect(self.fPatchbay.slot_configureCarla)

        parent.ParameterValueChangedCallback.connect(self.fRack.slot_handleParameterValueChangedCallback)
        parent.ParameterDefaultChangedCallback.connect(self.fRack.slot_handleParameterDefaultChangedCallback)
        parent.ParameterMidiChannelChangedCallback.connect(self.fRack.slot_handleParameterMidiChannelChangedCallback)
        parent.ParameterMidiCcChangedCallback.connect(self.fRack.slot_handleParameterMidiCcChangedCallback)
        parent.ProgramChangedCallback.connect(self.fRack.slot_handleProgramChangedCallback)
        parent.MidiProgramChangedCallback.connect(self.fRack.slot_handleMidiProgramChangedCallback)
        parent.UiStateChangedCallback.connect(self.fRack.slot_handleUiStateChangedCallback)
        parent.NoteOnCallback.connect(self.fRack.slot_handleNoteOnCallback)
        parent.NoteOnCallback.connect(self.fPatchbay.slot_handleNoteOnCallback)
        parent.NoteOffCallback.connect(self.fRack.slot_handleNoteOffCallback)
        parent.NoteOffCallback.connect(self.fPatchbay.slot_handleNoteOffCallback)
        parent.UpdateCallback.connect(self.fRack.slot_handleUpdateCallback)
        parent.ReloadInfoCallback.connect(self.fRack.slot_handleReloadInfoCallback)
        parent.ReloadParametersCallback.connect(self.fRack.slot_handleReloadParametersCallback)
        parent.ReloadProgramsCallback.connect(self.fRack.slot_handleReloadProgramsCallback)
        parent.ReloadAllCallback.connect(self.fRack.slot_handleReloadAllCallback)

        parent.PatchbayClientAddedCallback.connect(self.fPatchbay.slot_handlePatchbayClientAddedCallback)
        parent.PatchbayClientRemovedCallback.connect(self.fPatchbay.slot_handlePatchbayClientRemovedCallback)
        parent.PatchbayClientRenamedCallback.connect(self.fPatchbay.slot_handlePatchbayClientRenamedCallback)
        parent.PatchbayClientDataChangedCallback.connect(self.fPatchbay.slot_handlePatchbayClientDataChangedCallback)
        parent.PatchbayPortAddedCallback.connect(self.fPatchbay.slot_handlePatchbayPortAddedCallback)
        parent.PatchbayPortRemovedCallback.connect(self.fPatchbay.slot_handlePatchbayPortRemovedCallback)
        parent.PatchbayPortRenamedCallback.connect(self.fPatchbay.slot_handlePatchbayPortRenamedCallback)
        parent.PatchbayConnectionAddedCallback.connect(self.fPatchbay.slot_handlePatchbayConnectionAddedCallback)
        parent.PatchbayConnectionRemovedCallback.connect(self.fPatchbay.slot_handlePatchbayConnectionRemovedCallback)

    # -----------------------------------------------------------------

    def getPluginCount(self):
        return self.fRack.getPluginCount()

    # -----------------------------------------------------------------

    def addPlugin(self, pluginId, isProjectLoading):
        self.fRack.addPlugin(pluginId, isProjectLoading)
        self.fPatchbay.addPlugin(pluginId, isProjectLoading)

    def removePlugin(self, pluginId):
        self.fRack.removePlugin(pluginId)
        self.fPatchbay.removePlugin(pluginId)

    def renamePlugin(self, pluginId, newName):
        self.fRack.renamePlugin(pluginId, newName)

    def disablePlugin(self, pluginId, errorMsg):
        self.fRack.disablePlugin(pluginId)

    def removeAllPlugins(self):
        self.fRack.removeAllPlugins()

    # -----------------------------------------------------------------

    def engineStarted(self):
        #self.fRack.engineStarted()
        #self.fPatchbay.engineStarted()
        self.fParent.engineChanged()

    def engineStopped(self):
        #self.fRack.engineStopped()
        self.fPatchbay.engineStopped()
        self.fParent.engineStopped()

    def engineChanged(self):
        self.fParent.engineChanged()

    # -----------------------------------------------------------------

    def idleFast(self):
        self.fRack.idleFast()
        self.fPatchbay.idleFast()

    def idleSlow(self):
        self.fRack.idleSlow()

    # -----------------------------------------------------------------

    def projectLoaded(self):
        self.fPatchbay.projectLoaded()

    def saveSettings(self, settings):
        #self.fRack.saveSettings(settings)
        self.fPatchbay.saveSettings(settings)
        #self.fParent.saveSettings(settings)

    def showEditDialog(self, pluginId):
        self.fRack.showEditDialog(pluginId)

    # -----------------------------------------------------------------

    def fixCanvasPreviewSize(self):
        self.fPatchbay.resize(self.fRack.size())
        self.fPatchbay.slot_miniCanvasCheckSize()

    def setUseCustomPaint(self, useCustomPaint):
        if self.fUseCustomPaint != useCustomPaint:
            self.fUseCustomPaint = useCustomPaint
            self.update()

    def paintEvent(self, event):
        QTabWidget.paintEvent(self, event)

        if not self.fUseCustomPaint:
            return

        painter = QPainter(self)
        painter.setBrush(QColor(36, 36, 36))
        painter.setPen(QColor(62, 62, 62))
        painter.drawRect(1, self.height()/2, self.width()-3, self.height()-self.height()/2-1)

    def resizeEvent(self, event):
        QTabWidget.resizeEvent(self, event)

        if self.currentIndex() == 0:
            self.fixCanvasPreviewSize()

# ------------------------------------------------------------------------------------------------------------
# Main Window

class CarlaHostW(HostWindow):
    def __init__(self, parent=None):
        HostWindow.__init__(self, parent)

        # -------------------------------------------------------------
        # Set-up container

        self.fContainer = CarlaMultiW(self)
        self.setupContainer(True, self.fContainer.fPatchbay.themeData)

        self.fContainer.setUseCustomPaint(self.fSavedSettings[CARLA_KEY_CUSTOM_PAINTING])

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

        self.fInfoText  = ""
        self.fInfoLabel = QLabel(self)
        self.fInfoLabel.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
        self.fInfoLabel.setText("Engine stopped")

        if MACOS and False: # TODO: check if NOT using pro theme
            self.fInfoLabel.hide()
            self.setUnifiedTitleAndToolBarOnMac(True)

        # -------------------------------------------------------------

        self.ui.act_settings_show_toolbar.triggered.connect(self.slot_toolbarShown)
        self.ui.splitter.splitterMoved.connect(self.slot_splitterMoved)

        QTimer.singleShot(0, self.slot_initWidgets)

    # -----------------------------------------------------------------

    def engineStopped(self):
        self.fInfoText = ""
        self.fInfoLabel.setText("Engine stopped")

    def engineChanged(self):
        self.fInfoText = "Engine running | SampleRate: %g | BufferSize: %i" % (Carla.sampleRate, Carla.bufferSize)
        self.fInfoLabel.setText("%s | %s" % (self.fInfoText, self.fTextTransport))

    # -----------------------------------------------------------------

    def updateInfoLabelXandSize(self):
        tabBar = self.fContainer.tabBar()
        x = tabBar.width() + self.ui.tabUtils.width() + 20
        self.fInfoLabel.move(x, self.fInfoLabel.y())
        self.fInfoLabel.resize(self.fContainer.width()-tabBar.width()-20, self.fInfoLabel.height())

    def updateInfoLabelY(self):
        tabBar = self.fContainer.tabBar()
        y = tabBar.mapFromParent(self.ui.centralwidget.pos()).y()

        if not self.ui.toolBar.isVisible():
            y -= self.ui.toolBar.height()

        self.fInfoLabel.move(self.fInfoLabel.x(), y)

    # -----------------------------------------------------------------

    @pyqtSlot()
    def slot_initWidgets(self):
        tabBar = self.fContainer.tabBar()
        x = tabBar.width() + self.ui.tabUtils.width() + 20
        y = tabBar.mapFromParent(self.ui.centralwidget.pos()).y()

        self.fInfoLabel.move(x, y)
        self.fInfoLabel.resize(self.fContainer.width()-tabBar.width()-20, tabBar.height())

        # FIXME: Qt4 needs this so it properly creates & resizes the canvas
        self.fContainer.setCurrentIndex(1)
        self.fContainer.setCurrentIndex(0)
        self.fContainer.fixCanvasPreviewSize()

    @pyqtSlot()
    def slot_splitterMoved(self):
        self.updateInfoLabelXandSize()

    @pyqtSlot()
    def slot_toolbarShown(self):
        self.updateInfoLabelY()

    # -----------------------------------------------------------------

    def resizeEvent(self, event):
        HostWindow.resizeEvent(self, event)
        self.updateInfoLabelXandSize()

    def timerEvent(self, event):
        HostWindow.timerEvent(self, event)

        if event.timerId() == self.fIdleTimerFast:
            self.fInfoLabel.setText("%s | %s" % (self.fInfoText, self.fTextTransport))

# ------------------------------------------------------------------------------------------------------------
# Main

if __name__ == '__main__':
    # -------------------------------------------------------------
    # App initialization

    app = CarlaApplication()

    # -------------------------------------------------------------
    # Set-up custom signal handling

    setUpSignals()

    # -------------------------------------------------------------
    # Read CLI args

    appName = os.path.basename(__file__) if ("__file__" in dir() and os.path.dirname(__file__) in PATH) else sys.argv[0]
    libPrefix = None
    projectFilename = None

    argv = app.arguments()
    argc = len(argv)

    for i in range(argc):
        if i == 0: continue
        argument = argv[i]

        if argument.startswith("--with-appname="):
            appName = os.path.basename(argument.replace("--with-appname=", ""))

        elif argument.startswith("--with-libprefix="):
            libPrefix = argument.replace("--with-libprefix=", "")

        elif os.path.exists(argument):
            projectFilename = argument

    if libPrefix is not None:
        app.addLibraryPath(os.path.join(libPrefix, "lib", "carla"))

    # -------------------------------------------------------------
    # Init host backend

    Carla.isControl   = False
    Carla.isLocal     = True
    Carla.isPlugin    = False

    initHost(appName, libPrefix)

    # -------------------------------------------------------------
    # Create GUI

    Carla.gui = CarlaHostW()

    # set our gui as parent for all plugins UIs
    Carla.host.set_engine_option(ENGINE_OPTION_FRONTEND_WIN_ID, 0, str(Carla.gui.winId()))

    # -------------------------------------------------------------
    # Load project file if set

    if projectFilename is not None:
        Carla.gui.loadProjectLater(projectFilename)

    # -------------------------------------------------------------
    # Show GUI

    Carla.gui.show()

    # -------------------------------------------------------------
    # App-Loop

    sys.exit(app.exec_())