falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3301 Commits
17 Branches
116MB
Tree: aac0860247
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'aac0860247'
${ noResults }
Carla/source/native-plugins/zynaddsubfx/UI/Connection.cpp

488 lines
16KB
Raw Blame History 

  1. #include "Connection.h"

  2. #include "Fl_Osc_Interface.h"

  3. #include "../globals.h"

  4. #include <map>

  5. #include <cassert>

  6. 

  7. #include <rtosc/rtosc.h>

  8. #include <rtosc/ports.h>

  9. 

  10. #include <FL/Fl.H>

  11. #include "Fl_Osc_Tree.H"

  12. #include "common.H"

  13. #include "MasterUI.h"

  14. #include "../Misc/MiddleWare.h"

  15. 

  16. #ifdef NTK_GUI

  17. #include <FL/Fl_Shared_Image.H>

  18. #include <FL/Fl_Tiled_Image.H>

  19. #include <FL/Fl_Dial.H>

  20. #include <err.h>

  21. #endif // NTK_GUI

  22. 

  23. #ifndef NO_UI

  24. #include "Fl_Osc_Widget.H"

  25. #endif

  26. 

  27. using namespace GUI;

  28. class MasterUI *ui;

  29. #ifdef NTK_GUI

  30. static Fl_Tiled_Image *module_backdrop;

  31. #endif

  32. 

  33. int kb_shortcut_handler(int)

  34. {

  35.     const bool undo_ = Fl::event_ctrl() && Fl::event_key() == 'z';

  36.     const bool redo = Fl::event_ctrl() && Fl::event_key() == 'r';

  37.     const bool show = Fl::event_ctrl() && Fl::event_shift() &&

  38.         Fl::event_key() == 's';

  39.     const bool panel = Fl::event_ctrl() && Fl::event_shift() &&

  40.         Fl::event_key() == 'p';

  41.     if(undo_)

  42.         ui->osc->write("/undo", "");

  43.     else if(redo)

  44.         ui->osc->write("/redo", "");

  45.     else if (show) {

  46.         ui->simplemasterwindow->hide();

  47.         ui->masterwindow->show();

  48.     } else if (panel)

  49.         ui->panelwindow->show();

  50.     return undo_ || redo || show;

  51. }

  52. 

  53. void

  54. set_module_parameters ( Fl_Widget *o )

  55. {

  56. #ifdef NTK_GUI

  57.     o->box( FL_DOWN_FRAME );

  58.     o->align( o->align() | FL_ALIGN_IMAGE_BACKDROP );

  59.     o->color( FL_BLACK );

  60.     o->image( module_backdrop );

  61.     o->labeltype( FL_SHADOW_LABEL );

  62.     if(o->parent()) {

  63.         o->parent()->labeltype(FL_NO_LABEL);

  64.         o->parent()->box(FL_NO_BOX);

  65.     }

  66. #else

  67.     o->box( FL_PLASTIC_UP_BOX );

  68.     o->color( FL_CYAN );

  69.     o->labeltype( FL_EMBOSSED_LABEL );

  70. #endif

  71. }

  72. 

  73. ui_handle_t GUI::createUi(Fl_Osc_Interface *osc, void *exit)

  74. {

  75. #ifdef NTK_GUI

  76.     fl_register_images();

  77. 

  78.     Fl_Dial::default_style(Fl_Dial::PIXMAP_DIAL);

  79. 

  80. #ifdef CARLA_VERSION_STRING

  81.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(gUiPixmapPath + "knob.png"))

  82.         Fl_Dial::default_image(img);

  83. #else

  84.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/knob.png"))

  85.         Fl_Dial::default_image(img);

  86. #endif

  87.     else if(Fl_Shared_Image *img = Fl_Shared_Image::get(SOURCE_DIR "/pixmaps/knob.png"))

  88.         Fl_Dial::default_image(img);

  89.     else

  90.         errx(1, "ERROR: Cannot find pixmaps/knob.png");

  91. 

  92. 

  93. #ifdef CARLA_VERSION_STRING

  94.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(gUiPixmapPath + "/window_backdrop.png"))

  95.         Fl::scheme_bg(new Fl_Tiled_Image(img));

  96. #else

  97.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/window_backdrop.png"))

  98.         Fl::scheme_bg(new Fl_Tiled_Image(img));

  99. #endif

  100.     else if(Fl_Shared_Image *img = Fl_Shared_Image::get(SOURCE_DIR "/pixmaps/window_backdrop.png"))

  101.         Fl::scheme_bg(new Fl_Tiled_Image(img));

  102.     else

  103.         errx(1, "ERROR: Cannot find pixmaps/window_backdrop.png");

  104. 

  105. #ifdef CARLA_VERSION_STRING

  106.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(gUiPixmapPath + "/module_backdrop.png"))

  107.         module_backdrop = new Fl_Tiled_Image(img);

  108. #else

  109.     if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/module_backdrop.png"))

  110.         module_backdrop = new Fl_Tiled_Image(img);

  111. #endif

  112.     else if(Fl_Shared_Image *img = Fl_Shared_Image::get(SOURCE_DIR "/pixmaps/module_backdrop.png"))

  113.         module_backdrop = new Fl_Tiled_Image(img);

  114.     else

  115.         errx(1, "ERROR: Cannot find pixmaps/module_backdrop");

  116. 

  117.     Fl::background(50,  50,  50);

  118.     Fl::background2(70, 70,  70);

  119.     Fl::foreground(255, 255, 255);

  120. #endif

  121. 

  122.     //Fl_Window *midi_win = new Fl_Double_Window(400, 400, "Midi connections");

  123.     //Fl_Osc_Tree *tree   = new Fl_Osc_Tree(0,0,400,400);

  124.     //midi_win->resizable(tree);

  125.     //tree->root_ports    = &Master::ports;

  126.     //tree->osc           = osc;

  127.     //midi_win->show();

  128. 

  129.     Fl::add_handler(kb_shortcut_handler);

  130.     return (void*) (ui = new MasterUI((int*)exit, osc));

  131. }

  132. void GUI::destroyUi(ui_handle_t ui)

  133. {

  134.     delete static_cast<MasterUI*>(ui);

  135. }

  136. 

  137. #define BEGIN(x) {x,":non-realtime\0",NULL,[](const char *m, rtosc::RtData &d){ \

  138.     MasterUI *ui   = static_cast<MasterUI*>(d.obj); \

  139.     rtosc_arg_t a0 = {0}, a1 = {0}; \

  140.     if(rtosc_narguments(m) > 0) \

  141.         a0 = rtosc_argument(m,0); \

  142.     if(rtosc_narguments(m) > 1) \

  143.         a1 = rtosc_argument(m,1); \

  144.     (void)ui;(void)a1;(void)a0;

  145. 

  146. #define END }},

  147. 

  148. struct uiPorts {

  149.     static rtosc::Ports ports;

  150. };

  151. 

  152. //DSL based ports

  153. rtosc::Ports uiPorts::ports = {

  154.     BEGIN("show:i") {

  155.         ui->showUI(a0.i);

  156.     } END

  157.     BEGIN("alert:s") {

  158.         fl_alert("%s",a0.s);

  159.     } END

  160.     BEGIN("alert-reload:i") {

  161.         int res = fl_choice("Old autosave found, do you want to reload?",

  162.                 "Delete", "Reload", "Ignore");

  163.         //       0        1          2

  164.         if(1==res) {

  165.             d.reply("/reload_auto_save", "i", a0.i);

  166.             ui->refresh_master_ui();

  167.             ui->updatepanel();

  168.         } else if(0==res) {

  169.             d.reply("/delete_auto_save", "i", a0.i);

  170.         }

  171.     } END

  172.     BEGIN("session-type:s") {

  173.         if(strcmp(a0.s,"LASH"))

  174.             return;

  175.         ui->sm_indicator1->value(1);

  176.         ui->sm_indicator2->value(1);

  177.         ui->sm_indicator1->tooltip("LASH");

  178.         ui->sm_indicator2->tooltip("LASH");

  179.     } END

  180.     BEGIN("save-master:s") {

  181.         ui->do_save_master(a0.s);

  182.     } END

  183.     BEGIN("load-master:s") {

  184.         ui->do_load_master(a0.s);

  185.     } END

  186.     BEGIN("vu-meter:bb") {

  187.         if(a0.b.len == sizeof(vuData) &&

  188.                 a1.b.len == sizeof(float)*NUM_MIDI_PARTS) {

  189.             //Refresh the primary VU meters

  190.             ui->simplemastervu->update((vuData*)a0.b.data);

  191.             ui->mastervu->update((vuData*)a0.b.data);

  192. 

  193.             float *partvu = (float*)a1.b.data;

  194.             for(int i=0; i<NUM_MIDI_PARTS; ++i)

  195.                 ui->panellistitem[i]->partvu->update(partvu[i]);

  196.         }

  197.     } END

  198.     BEGIN("close-ui") {

  199.         ui->close();

  200.     } END

  201. };

  202. 

  203. //very tiny rtdata ext

  204. class RtDataUI: public rtosc::RtData {

  205. public:

  206. 

  207.     RtDataUI(Fl_Osc_Interface *osc_)

  208.         :osc(osc_)

  209.     {}

  210. 

  211.     void reply(const char *path, const char *args, ...) override

  212.     {

  213.         va_list va;

  214.         va_start(va,args);

  215.         char buf[2048];

  216.         rtosc_vmessage(buf,sizeof(buf),path,args,va);

  217.         osc->writeRaw(buf);

  218.         va_end(va);

  219.     }

  220. 

  221.     Fl_Osc_Interface *osc;

  222. };

  223. 

  224. void GUI::raiseUi(ui_handle_t gui, const char *message)

  225. {

  226.     if(!gui)

  227.         return;

  228.     MasterUI *mui = (MasterUI*)gui;

  229.     if(string("/damage") == message && rtosc_type(message, 0) == 's') {

  230.         string damage_str = rtosc_argument(message,0).s;

  231.         int npart = -1;

  232.         if(sscanf(damage_str.c_str(), "/part%d", &npart) == 1 && damage_str.size() < 10) {

  233.             if(mui->npartcounter->value()-1 == npart) {

  234.                 mui->partui->showparameters(0,-1);

  235.                 mui->npartcounter->do_callback();

  236.             }

  237.         }

  238.         mui->osc->damage(rtosc_argument(message,0).s);

  239.     }

  240.     mui->osc->tryLink(message);

  241.     //printf("got message for UI '%s'\n", message);

  242.     char buffer[1024];

  243.     memset(buffer, 0, sizeof(buffer));

  244.     RtDataUI d(mui->osc);

  245.     d.loc = buffer;

  246.     d.loc_size = 1024;

  247.     d.obj = gui;

  248.     uiPorts::ports.dispatch(message+1, d);

  249. }

  250. 

  251. void GUI::raiseUi(ui_handle_t gui, const char *dest, const char *args, ...)

  252. {

  253.     char buffer[1024];

  254.     va_list va;

  255.     va_start(va,args);

  256.     if(rtosc_vmessage(buffer,1024,dest,args,va))

  257.         raiseUi(gui, buffer);

  258.     va_end(va);

  259. }

  260. 

  261. void GUI::tickUi(ui_handle_t)

  262. {

  263.     Fl::wait(0.02f);

  264. }

  265. 

  266. /******************************************************************************

  267.  *    OSC Interface For User Interface                                        *

  268.  *                                                                            *

  269.  *    This is a largely out of date section of code                           *

  270.  *    Most type specific write methods are no longer used                     *

  271.  *    See UI/Fl_Osc_* to see what is actually used in this interface          *

  272.  ******************************************************************************/

  273. class UI_Interface:public Fl_Osc_Interface

  274. {

  275.     public:

  276.         UI_Interface(MiddleWare *impl_)

  277.             :impl(impl_)

  278.         {}

  279. 

  280.         void requestValue(string s) override

  281.         {

  282.             assert(s!="/Psysefxvol-1/part0");

  283.             //Fl_Osc_Interface::requestValue(s);

  284.             char *tmp = strdup(s.c_str());

  285.             s = rtosc::Ports::collapsePath(tmp);

  286.             free(tmp);

  287.             if(impl->activeUrl() != "GUI") {

  288.                 impl->transmitMsg("/echo", "ss", "OSC_URL", "GUI");

  289.                 impl->activeUrl("GUI");

  290.             }

  291. 

  292.             impl->transmitMsg(s.c_str(),"");

  293.         }

  294. 

  295.         void write(string s, const char *args, ...) override

  296.         {

  297.             char *tmp = strdup(s.c_str());

  298.             s = rtosc::Ports::collapsePath(tmp);

  299.             free(tmp);

  300.             va_list va;

  301.             va_start(va, args);

  302.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 4 + 30, 0 + 40);

  303.             ////fprintf(stderr, ".");

  304.             //fprintf(stderr, "write(%s:%s)\n", s.c_str(), args);

  305.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  306.             impl->transmitMsg_va(s.c_str(), args, va);

  307.             va_end(va);

  308.         }

  309. 

  310.         void writeRaw(const char *msg) override

  311.         {

  312.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 4 + 30, 0 + 40);

  313.             ////fprintf(stderr, ".");

  314.             //fprintf(stderr, "rawWrite(%s:%s)\n", msg, rtosc_argument_string(msg));

  315.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  316.             impl->transmitMsg(rtosc::Ports::collapsePath((char*)msg));

  317.         }

  318. 

  319.         void writeValue(string s, string ss) override

  320.         {

  321.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 4 + 30, 0 + 40);

  322.             //fprintf(stderr, "writevalue<string>(%s,%s)\n", s.c_str(),ss.c_str());

  323.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  324.             write(s, "s", ss.c_str());

  325.         }

  326. 

  327.         void writeValue(string s, char c) override

  328.         {

  329.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 4 + 30, 0 + 40);

  330.             //fprintf(stderr, "writevalue<char>(%s,%d)\n", s.c_str(),c);

  331.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  332.             write(s, "c", c);

  333.         }

  334. 

  335.         void writeValue(string s, float f) override

  336.         {

  337.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 4 + 30, 0 + 40);

  338.             //fprintf(stderr, "writevalue<float>(%s,%f)\n", s.c_str(),f);

  339.             //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  340.             write(s, "f", f);

  341.         }

  342. 

  343.         void createLink(string s, class Fl_Osc_Widget*w) override

  344.         {

  345.             char *tmp = strdup(s.c_str());

  346.             s = rtosc::Ports::collapsePath(tmp);

  347.             free(tmp);

  348.             assert(s.length() != 0);

  349.             Fl_Osc_Interface::createLink(s,w);

  350.             assert(!strstr(s.c_str(), "/part0/kit-1"));

  351.             map.insert(std::pair<string,Fl_Osc_Widget*>(s,w));

  352.         }

  353. 

  354.         void renameLink(string old, string newer, Fl_Osc_Widget *w) override

  355.         {

  356.             //fprintf(stdout, "renameLink('%s','%s',%p)\n",

  357.             //        old.c_str(), newer.c_str(), w);

  358.             removeLink(old, w);

  359.             createLink(newer, w);

  360.         }

  361. 

  362.         void removeLink(string s, class Fl_Osc_Widget*w) override

  363.         {

  364.             char *tmp = strdup(s.c_str());

  365.             s = rtosc::Ports::collapsePath(tmp);

  366.             free(tmp);

  367.             for(auto i = map.begin(); i != map.end(); ++i) {

  368.                 if(i->first == s && i->second == w) {

  369.                     map.erase(i);

  370.                     break;

  371.                 }

  372.             }

  373.             //printf("[%d] removing '%s' (%p)...\n", map.size(), s.c_str(), w);

  374.         }

  375. 

  376.         virtual void removeLink(class Fl_Osc_Widget *w) override

  377.         {

  378.             bool processing = true;

  379.             while(processing)

  380.             {

  381.                 //Verify Iterator invalidation sillyness

  382.                 processing = false;//Exit if no new elements are found

  383.                 for(auto i = map.begin(); i != map.end(); ++i) {

  384.                     if(i->second == w) {

  385.                         //printf("[%d] removing '%s' (%p)...\n", map.size()-1,

  386.                         //        i->first.c_str(), w);

  387.                         map.erase(i);

  388.                         processing = true;

  389.                         break;

  390.                     }

  391.                 }

  392.             }

  393.         }

  394. 

  395.         //A very simplistic implementation of a UI agnostic refresh method

  396.         virtual void damage(const char *path) override

  397.         {

  398. #ifndef NO_UI

  399.             printf("\n\nDamage(\"%s\")\n", path);

  400.             std::set<Fl_Osc_Widget*> to_update;

  401.             for(auto pair:map) {

  402.                 if(strstr(pair.first.c_str(), path)) {

  403.                     auto *tmp = dynamic_cast<Fl_Widget*>(pair.second);

  404.                     if(!tmp || tmp->visible_r()) {

  405.                         to_update.insert(pair.second);

  406.                     }

  407.                 }

  408.             }

  409. 

  410.             for(auto elm:to_update)

  411.                 elm->update();

  412. #endif

  413.         }

  414. 

  415.         void tryLink(const char *msg) override

  416.         {

  417.             //DEBUG

  418.             //if(strcmp(msg, "/vu-meter"))//Ignore repeated message

  419.             //    printf("trying the link for a '%s'<%s>\n", msg, rtosc_argument_string(msg));

  420.             const char *handle = rindex(msg,'/');

  421.             if(handle)

  422.                 ++handle;

  423. 

  424.             int found_count = 0;

  425. 

  426.             auto range = map.equal_range(msg);

  427.             for(auto itr = range.first; itr != range.second; ++itr) {

  428.                 auto widget = itr->second;

  429.                 found_count++;

  430.                 const char *arg_str = rtosc_argument_string(msg);

  431. 

  432.                 //Always provide the raw message

  433.                 widget->OSC_raw(msg);

  434. 

  435.                 if(!strcmp(arg_str, "b")) {

  436.                     widget->OSC_value(rtosc_argument(msg,0).b.len,

  437.                             rtosc_argument(msg,0).b.data,

  438.                             handle);

  439.                 } else if(!strcmp(arg_str, "c")) {

  440.                     widget->OSC_value((char)rtosc_argument(msg,0).i,

  441.                             handle);

  442.                 } else if(!strcmp(arg_str, "s")) {

  443.                     widget->OSC_value((const char*)rtosc_argument(msg,0).s,

  444.                             handle);

  445.                 } else if(!strcmp(arg_str, "i")) {

  446.                     widget->OSC_value((int)rtosc_argument(msg,0).i,

  447.                             handle);

  448.                 } else if(!strcmp(arg_str, "f")) {

  449.                     widget->OSC_value((float)rtosc_argument(msg,0).f,

  450.                             handle);

  451.                 } else if(!strcmp(arg_str, "T") || !strcmp(arg_str, "F")) {

  452.                     widget->OSC_value((bool)rtosc_argument(msg,0).T, handle);

  453.                 }

  454.             }

  455. 

  456.             if(found_count == 0

  457.                     && strcmp(msg, "/vu-meter")

  458.                     && strcmp(msg, "undo_change")

  459.                     && !strstr(msg, "parameter")

  460.                     && !strstr(msg, "Prespoint")) {

  461.                 //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 1, 7 + 30, 0 + 40);

  462.                 //fprintf(stderr, "Unknown widget '%s'\n", msg);

  463.                 //fprintf(stderr, "%c[%d;%d;%dm", 0x1B, 0, 7 + 30, 0 + 40);

  464.             }

  465.         };

  466. 

  467.         void dumpLookupTable(void)

  468.         {

  469.             if(!map.empty()) {

  470.                 printf("Leaked controls:\n");

  471.                 for(auto i = map.begin(); i != map.end(); ++i) {

  472.                     printf("Known control  '%s' (%p)...\n", i->first.c_str(), i->second);

  473.                 }

  474.             }

  475.         }

  476. 

  477. 

  478.     private:

  479.         std::multimap<string,Fl_Osc_Widget*> map;

  480.         MiddleWare *impl;

  481. };

  482. 

  483. Fl_Osc_Interface *GUI::genOscInterface(MiddleWare *mw)

  484. {

  485.     return new UI_Interface(mw);

  486. }