source/includes/CarlaNativeExtUI.hpp

   1 /*
   2  * Carla Native Plugin API (C++)
   3  * Copyright (C) 2012-2022 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #ifndef CARLA_NATIVE_EXTERNAL_UI_HPP_INCLUDED
  19 #define CARLA_NATIVE_EXTERNAL_UI_HPP_INCLUDED
  20
  21 #include "CarlaNative.hpp"
  22 #include "CarlaExternalUI.hpp"
  23 #include "CarlaMIDI.h"
  24
  25 /*!
  26  * @defgroup CarlaNativeAPI Carla Native API
  27  * @{
  28  */
  29
  30 // -----------------------------------------------------------------------
  31 // Native Plugin and External UI class
  32
  33 class NativePluginAndUiClass : public NativePluginClass
  34 #ifndef CARLA_OS_WASM
  35                              , public CarlaExternalUI
  36 #endif
  37 {
  38 public:
  39     NativePluginAndUiClass(const NativeHostDescriptor* const host, const char* const pathToExternalUI)
  40         : NativePluginClass(host),
  41 #ifndef CARLA_OS_WASM
  42           CarlaExternalUI(),
  43 #endif
  44           fExtUiPath(getResourceDir())
  45     {
  46         fExtUiPath += CARLA_OS_SEP_STR;
  47         fExtUiPath += pathToExternalUI;
  48 #ifdef CARLA_OS_WIN
  49         fExtUiPath += ".exe";
  50 #endif
  51     }
  52
  53     const char* getExtUiPath() const noexcept
  54     {
  55         return fExtUiPath;
  56     }
  57
  58 #ifndef CARLA_OS_WASM
  59 protected:
  60     // -------------------------------------------------------------------
  61     // Plugin UI calls
  62
  63     void uiShow(const bool show) override
  64     {
  65         if (show)
  66         {
  67             if (isPipeRunning())
  68             {
  69                 writeFocusMessage();
  70                 return;
  71             }
  72
  73             carla_stdout("Trying to start UI using \"%s\"", fExtUiPath.buffer());
  74
  75             CarlaExternalUI::setData(fExtUiPath, getSampleRate(), getUiName());
  76
  77             if (! CarlaExternalUI::startPipeServer(true))
  78             {
  79                 uiClosed();
  80                 hostUiUnavailable();
  81             }
  82         }
  83         else
  84         {
  85             CarlaExternalUI::stopPipeServer(2000);
  86         }
  87     }
  88
  89     void uiIdle() override
  90     {
  91         CarlaExternalUI::idlePipe();
  92
  93         switch (CarlaExternalUI::getAndResetUiState())
  94         {
  95         case CarlaExternalUI::UiNone:
  96         case CarlaExternalUI::UiShow:
  97             break;
  98         case CarlaExternalUI::UiCrashed:
  99             uiClosed();
 100             hostUiUnavailable();
 101             break;
 102         case CarlaExternalUI::UiHide:
 103             uiClosed();
 104             CarlaExternalUI::stopPipeServer(1000);
 105             break;
 106         }
 107     }
 108
 109     void uiSetParameterValue(const uint32_t index, const float value) noexcept override
 110     {
 111         CARLA_SAFE_ASSERT_RETURN(index < getParameterCount(),);
 112
 113         writeControlMessage(index, value);
 114     }
 115
 116     void uiSetMidiProgram(const uint8_t channel, const uint32_t bank, const uint32_t program) noexcept override
 117     {
 118         CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
 119
 120         writeProgramMessage(channel, bank, program);
 121     }
 122
 123     void uiSetCustomData(const char* const key, const char* const value) noexcept override
 124     {
 125         CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
 126         CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
 127
 128         writeConfigureMessage(key, value);
 129     }
 130
 131     void uiNameChanged(const char* const uiName) override
 132     {
 133         CARLA_SAFE_ASSERT_RETURN(uiName != nullptr && uiName[0] != '\0',);
 134
 135         const CarlaMutexLocker cml(getPipeLock());
 136
 137         if (! writeMessage("uiTitle\n", 8))
 138             return;
 139         if (! writeAndFixMessage(uiName))
 140             return;
 141
 142         syncMessages();
 143     }
 144
 145     bool uiMIDIEvent(const uint8_t size, const uint8_t data[]) override
 146     {
 147         if (size != 3)
 148             return false;
 149
 150         const uint8_t status = MIDI_GET_STATUS_FROM_DATA(data);
 151
 152         if (! (MIDI_IS_STATUS_NOTE_ON(status) || MIDI_IS_STATUS_NOTE_OFF(status)))
 153             return false;
 154
 155         writeMidiNoteMessage(MIDI_IS_STATUS_NOTE_ON(status),
 156                              MIDI_GET_CHANNEL_FROM_DATA(data),
 157                              data[1], data[2]);
 158         return true;
 159     }
 160
 161     // -------------------------------------------------------------------
 162     // Pipe Server calls
 163
 164     bool msgReceived(const char* const msg) noexcept override
 165     {
 166         if (CarlaExternalUI::msgReceived(msg))
 167             return true;
 168
 169         if (std::strcmp(msg, "control") == 0)
 170         {
 171             uint32_t param;
 172             float value;
 173
 174             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(param), true);
 175             CARLA_SAFE_ASSERT_RETURN(readNextLineAsFloat(value), true);
 176
 177             try {
 178                 uiParameterChanged(param, value);
 179             } CARLA_SAFE_EXCEPTION("uiParameterChanged");
 180
 181             return true;
 182         }
 183
 184         if (std::strcmp(msg, "program") == 0)
 185         {
 186             uint8_t channel;
 187             uint32_t bank, program;
 188
 189             CARLA_SAFE_ASSERT_RETURN(readNextLineAsByte(channel), true);
 190             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(bank), true);
 191             CARLA_SAFE_ASSERT_RETURN(readNextLineAsUInt(program), true);
 192             CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS, true);
 193
 194             try {
 195                 uiMidiProgramChanged(static_cast<uint8_t>(channel), bank, program);
 196             } CARLA_SAFE_EXCEPTION("uiMidiProgramChanged");
 197
 198             return true;
 199         }
 200
 201         if (std::strcmp(msg, "configure") == 0)
 202         {
 203             const char* key;
 204             const char* value;
 205
 206             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(key, true), true);
 207             CARLA_SAFE_ASSERT_RETURN(readNextLineAsString(value, false), true);
 208
 209             try {
 210                 uiCustomDataChanged(key, value);
 211             } CARLA_SAFE_EXCEPTION("uiCustomDataChanged");
 212
 213             delete[] key;
 214
 215             return true;
 216         }
 217
 218         return false;
 219     }
 220 #endif
 221
 222 private:
 223     CarlaString fExtUiPath;
 224
 225     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(NativePluginAndUiClass)
 226 };
 227
 228 /**@}*/
 229
 230 // -----------------------------------------------------------------------
 231
 232 #endif // CARLA_NATIVE_EXTERNAL_UI_HPP_INCLUDED