gtk2_ardour/linux_vst_gui_support.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3     Based on code by Paul Davis, Torben Hohn as part of FST
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) 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     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 /******************************************************************/
  22 /** VSTFX - An engine based on FST for handling linuxVST plugins **/
  23 /******************************************************************/
  24
  25 /** EDITOR tab stops at 4 **/
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <jack/jack.h>
  30 #include <jack/thread.h>
  31 #include <libgen.h>
  32
  33 #include <pthread.h>
  34 #include <signal.h>
  35 #include <glib.h>
  36 #include <glibmm/timer.h>
  37
  38 #include "ardour/linux_vst_support.h"
  39
  40 #include <X11/X.h>
  41 #include <X11/Xlib.h>
  42 #include <dlfcn.h>
  43 #include <string.h>
  44 #include <time.h>
  45 #include <unistd.h>
  46 #include <pthread.h>
  47
  48 struct ERect{
  49     short top;
  50     short left;
  51     short bottom;
  52     short right;
  53 };
  54
  55 static pthread_mutex_t plugin_mutex;
  56
  57 static VSTState * vstfx_first = NULL;
  58
  59 const char magic[] = "VSTFX Plugin State v002";
  60
  61 int  gui_thread_id = 0;
  62 static int gui_quit = 0;
  63
  64 /*This will be our connection to X*/
  65
  66 Display* LXVST_XDisplay = NULL;
  67
  68 /*The thread handle for the GUI event loop*/
  69
  70 pthread_t LXVST_gui_event_thread;
  71
  72 /*Util functions to get the value of a property attached to an XWindow*/
  73
  74 bool LXVST_xerror;
  75
  76 int TempErrorHandler(Display *display, XErrorEvent *e)
  77 {
  78         LXVST_xerror = true;
  79
  80         return 0;
  81 }
  82
  83 #ifdef LXVST_32BIT
  84
  85 int getXWindowProperty(Window window, Atom atom)
  86 {
  87         int result = 0;
  88         int userSize;
  89         unsigned long bytes;
  90         unsigned long userCount;
  91         unsigned char *data;
  92         Atom userType;
  93         LXVST_xerror = false;
  94
  95         /*Use our own Xerror handler while we're in here - in an
  96         attempt to stop the brain dead default Xerror behaviour of
  97         qutting the entire application because of e.g. an invalid
  98         window ID*/
  99
 100         XErrorHandler olderrorhandler = XSetErrorHandler(TempErrorHandler);
 101
 102         XGetWindowProperty(     LXVST_XDisplay,                 //The display
 103                                                 window,                                 //The Window
 104                                                 atom,                                   //The property
 105                                                 0,                                              //Offset into the data
 106                                                 1,                                              //Number of 32Bit chunks of data
 107                                                 false,                                  //false = don't delete the property
 108                                                 AnyPropertyType,                //Required property type mask
 109                                                 &userType,                              //Actual type returned
 110                                                 &userSize,                              //Actual format returned
 111                                                 &userCount,                             //Actual number of items stored in the returned data
 112                                                 &bytes,                                 //Number of bytes remaining if a partial read
 113                                                 &data);                                 //The actual data read
 114
 115         if(LXVST_xerror == false && userCount == 1)
 116                 result = *(int*)data;
 117
 118         XSetErrorHandler(olderrorhandler);
 119
 120         /*Hopefully this will return zero if the property is not set*/
 121
 122         return result;
 123 }
 124
 125 #endif
 126
 127 #ifdef LXVST_64BIT
 128
 129 /********************************************************************/
 130 /* This is untested - have no 64Bit plugins which use this          */
 131 /* system of passing an eventProc address                           */
 132 /********************************************************************/
 133
 134 long getXWindowProperty(Window window, Atom atom)
 135 {
 136         long result = 0;
 137         int userSize;
 138         unsigned long bytes;
 139         unsigned long userCount;
 140         unsigned char *data;
 141         Atom userType;
 142         LXVST_xerror = false;
 143
 144         /*Use our own Xerror handler while we're in here - in an
 145         attempt to stop the brain dead default Xerror behaviour of
 146         qutting the entire application because of e.g. an invalid
 147         window ID*/
 148
 149         XErrorHandler olderrorhandler = XSetErrorHandler(TempErrorHandler);
 150
 151         XGetWindowProperty(     LXVST_XDisplay,
 152                                                 window,
 153                                                 atom,
 154                                                 0,
 155                                                 2,
 156                                                 false,
 157                                                 AnyPropertyType,
 158                                                 &userType,
 159                                                 &userSize,
 160                                                 &userCount,
 161                                                 &bytes,
 162                                                 &data);
 163
 164         if(LXVST_xerror == false && userCount == 1)
 165                 result = *(long*)data;
 166
 167         XSetErrorHandler(olderrorhandler);
 168
 169         /*Hopefully this will return zero if the property is not set*/
 170
 171         return result;
 172 }
 173
 174 #endif
 175
 176 /*The event handler - called from within the main GUI thread to
 177 dispatch events to any VST UIs which have callbacks stuck to them*/
 178
 179 static void
 180 dispatch_x_events (XEvent* event, VSTState* vstfx)
 181 {
 182         /*Handle some of the Events we might be interested in*/
 183
 184         switch(event->type)
 185         {
 186                 /*Configure event - when the window is resized or first drawn*/
 187
 188                 case ConfigureNotify:
 189                 {
 190                         Window window = event->xconfigure.event;
 191
 192                         int width = event->xconfigure.width;
 193                         int height = event->xconfigure.height;
 194
 195                         /*If we get a config notify on the parent window XID then we need to see
 196                         if the size has been changed - some plugins re-size their UI window e.g.
 197                         when opening a preset manager (you might think that should be spawned as a new window...) */
 198
 199                         /*if the size has changed, we flag this so that in lxvst_pluginui.cc we can make the
 200                         change to the GTK parent window in ardour, from its UI thread*/
 201
 202                         if (window == (Window) (vstfx->linux_window)) {
 203                                 if (width != vstfx->width || height!=vstfx->height) {
 204                                         vstfx->width = width;
 205                                         vstfx->height = height;
 206                                         vstfx->want_resize = 1;
 207
 208                                         /*QUIRK : Loomer plugins not only resize the UI but throw it into some random
 209                                         position at the same time. We need to re-position the window at the origin of
 210                                         the parent window*/
 211
 212                                         if (vstfx->linux_plugin_ui_window) {
 213                                                 XMoveWindow (LXVST_XDisplay, vstfx->linux_plugin_ui_window, 0, 0);
 214                                         }
 215                                 }
 216                         }
 217
 218                         break;
 219
 220                 }
 221
 222                 /*Reparent Notify - when the plugin UI is reparented into
 223                 our Host Window we will get an event here... probably... */
 224
 225                 case ReparentNotify:
 226                 {
 227                         Window ParentWindow = event->xreparent.parent;
 228
 229                         /*If the ParentWindow matches the window for the vstfx instance then
 230                         the Child window must be the XID of the pluginUI window created by the
 231                         plugin, so we need to see if it has a callback stuck to it, and if so
 232                         set that up in the vstfx */
 233
 234                         /***********************************************************/
 235                         /* 64Bit --- This mechanism is not 64Bit compatible at the */
 236                         /* present time                                            */
 237                         /***********************************************************/
 238
 239                         if (ParentWindow == (Window) (vstfx->linux_window)) {
 240
 241                                 Window PluginUIWindowID = event->xreparent.window;
 242
 243                                 vstfx->linux_plugin_ui_window = PluginUIWindowID;
 244 #ifdef LXVST_32BIT
 245                                 int result = getXWindowProperty(PluginUIWindowID, XInternAtom(LXVST_XDisplay, "_XEventProc", false));
 246
 247                                 if (result == 0) {
 248                                         vstfx->eventProc = NULL;
 249                                 } else {
 250                                         vstfx->eventProc = (void (*) (void* event))result;
 251                                 }
 252 #endif
 253 #ifdef LXVST_64BIT
 254                                 long result = getXWindowProperty(PluginUIWindowID, XInternAtom(LXVST_XDisplay, "_XEventProc", false));
 255
 256                                 if(result == 0)
 257                                         vstfx->eventProc = NULL;
 258                                 else
 259                                         vstfx->eventProc = (void (*) (void* event))result;
 260 #endif
 261                         }
 262                         break;
 263                 }
 264
 265                 case ClientMessage:
 266                 {
 267                         Window window = event->xany.window;
 268                         Atom message_type = event->xclient.message_type;
 269
 270                         /*The only client message we are interested in is to signal
 271                         that the plugin parent window is now valid and can be passed
 272                         to effEditOpen when the editor is launched*/
 273
 274                         if (window == (Window) (vstfx->linux_window)) {
 275                                 char* message = XGetAtomName(LXVST_XDisplay, message_type);
 276
 277                                 if (strcmp(message,"LaunchEditor") == 0) {
 278                                         if (event->xclient.data.l[0] == 0x0FEEDBAC) {
 279                                                 vstfx_launch_editor (vstfx);
 280                                         }
 281                                 }
 282
 283                                 XFree(message);
 284                         }
 285                         break;
 286                 }
 287
 288                 default:
 289                         break;
 290         }
 291
 292         /* Some VSTs built with toolkits e.g. JUCE will manager their own UI
 293         autonomously in the plugin, running the UI in its own thread, so once
 294         we have created a parent window for the plugin, its UI takes care of
 295         itself.*/
 296
 297         /*Other types register a callback as an Xwindow property on the plugin
 298         UI window after they create it.  If that is the case, we need to call it
 299         here, passing the XEvent into it*/
 300
 301         if (vstfx->eventProc == NULL) {
 302                 return;
 303         }
 304
 305         vstfx->eventProc((void*)event);
 306 }
 307
 308 static void
 309 maybe_set_program (VSTState* vstfx)
 310 {
 311         if (vstfx->want_program != -1) {
 312                 if (vstfx->vst_version >= 2) {
 313                         vstfx->plugin->dispatcher (vstfx->plugin, 67 /* effBeginSetProgram */, 0, 0, NULL, 0);
 314                 }
 315
 316                 vstfx->plugin->dispatcher (vstfx->plugin, effSetProgram, 0, vstfx->want_program, NULL, 0);
 317
 318                 if (vstfx->vst_version >= 2) {
 319                         vstfx->plugin->dispatcher (vstfx->plugin, 68 /* effEndSetProgram */, 0, 0, NULL, 0);
 320                 }
 321
 322                 vstfx->want_program = -1;
 323         }
 324
 325         if (vstfx->want_chunk == 1) {
 326                 vstfx->plugin->dispatcher (vstfx->plugin, 24 /* effSetChunk */, 1, vstfx->wanted_chunk_size, vstfx->wanted_chunk, 0);
 327                 vstfx->want_chunk = 0;
 328         }
 329 }
 330
 331 /** This is the main gui event loop for the plugin, we also need to pass
 332 any Xevents to all the UI callbacks plugins 'may' have registered on their
 333 windows, that is if they don't manage their own UIs **/
 334
 335 void* gui_event_loop (void* ptr)
 336 {
 337         VSTState* vstfx;
 338         int LXVST_sched_event_timer = 0;
 339         int LXVST_sched_timer_interval = 50; //ms
 340         XEvent event;
 341
 342         /*The 'Forever' loop - runs the plugin UIs etc - based on the FST gui event loop*/
 343
 344         while (!gui_quit)
 345         {
 346                 /* handle window creation requests, destroy requests,
 347                    and run idle callbacks */
 348
 349                 /*Look at the XEvent queue - if there are any XEvents we need to handle them,
 350                 including passing them to all the plugin (eventProcs) we are currently managing*/
 351
 352                 if(LXVST_XDisplay)
 353                 {
 354                         /*See if there are any events in the queue*/
 355
 356                         int num_events = XPending(LXVST_XDisplay);
 357
 358                         /*process them if there are any*/
 359
 360                         while(num_events)
 361                         {
 362                                 XNextEvent(LXVST_XDisplay, &event);
 363
 364                                 /*Call dispatch events, with the event, for each plugin in the linked list*/
 365
 366                                 for (vstfx = vstfx_first; vstfx; vstfx = vstfx->next)
 367                                 {
 368                                         pthread_mutex_lock(&vstfx->lock);
 369
 370                                         dispatch_x_events(&event, vstfx);
 371
 372                                         pthread_mutex_unlock(&vstfx->lock);
 373                                 }
 374
 375                                 num_events--;
 376                         }
 377                 }
 378
 379                 /*We don't want to use all the CPU.. */
 380
 381                 Glib::usleep(1000);
 382
 383                 LXVST_sched_event_timer++;
 384
 385                 LXVST_sched_event_timer = LXVST_sched_event_timer & 0x00FFFFFF;
 386
 387                 /*See if its time for us to do a scheduled event pass on all the plugins*/
 388
 389                 if((LXVST_sched_timer_interval!=0) && (!(LXVST_sched_event_timer% LXVST_sched_timer_interval)))
 390                 {
 391                         pthread_mutex_lock (&plugin_mutex);
 392
 393 again:
 394                         /*Parse through the linked list of plugins*/
 395
 396                         for (vstfx = vstfx_first; vstfx; vstfx = vstfx->next)
 397                         {
 398                                 pthread_mutex_lock (&vstfx->lock);
 399
 400                                 /*Window scheduled for destruction*/
 401
 402                                 if (vstfx->destroy) {
 403                                         if (vstfx->linux_window) {
 404                                                 vstfx->plugin->dispatcher (vstfx->plugin, effEditClose, 0, 0, NULL, 0.0);
 405
 406                                                 XDestroyWindow (LXVST_XDisplay, vstfx->linux_window);
 407                                                 /* FIXME - probably safe to assume we never have an XID of 0 but not explicitly true */
 408                                                 vstfx->linux_window = 0;
 409                                                 vstfx->destroy = FALSE;
 410                                         }
 411
 412                                         vstfx_event_loop_remove_plugin (vstfx);
 413                                         vstfx->been_activated = FALSE;
 414                                         pthread_cond_signal (&vstfx->window_status_change);
 415                                         pthread_mutex_unlock (&vstfx->lock);
 416
 417                                         goto again;
 418                                 }
 419
 420                                 /*Window does not yet exist - scheduled for creation*/
 421
 422                                 /* FIXME - probably safe to assume 0 is not a valid XID but not explicitly true */
 423                                 if (vstfx->linux_window == 0) {
 424                                         if (vstfx_create_editor (vstfx)) {
 425                                                 vstfx_error ("** ERROR ** VSTFX : Cannot create editor for plugin %s", vstfx->handle->name);
 426                                                 vstfx_event_loop_remove_plugin (vstfx);
 427                                                 pthread_cond_signal (&vstfx->window_status_change);
 428                                                 pthread_mutex_unlock (&vstfx->lock);
 429                                                 goto again;
 430                                         } else {
 431                                                 /* condition/unlock: it was signalled & unlocked in fst_create_editor()   */
 432                                         }
 433                                 }
 434
 435                                 maybe_set_program (vstfx);
 436                                 vstfx->want_program = -1;
 437                                 vstfx->want_chunk = 0;
 438
 439                                 /*scheduled call to dispatcher*/
 440
 441                                 if (vstfx->dispatcher_wantcall) {
 442                                         vstfx->dispatcher_retval = vstfx->plugin->dispatcher (
 443                                                 vstfx->plugin,
 444                                                 vstfx->dispatcher_opcode,
 445                                                 vstfx->dispatcher_index,
 446                                                 vstfx->dispatcher_val,
 447                                                 vstfx->dispatcher_ptr,
 448                                                 vstfx->dispatcher_opt
 449                                                 );
 450
 451                                         vstfx->dispatcher_wantcall = 0;
 452                                         pthread_cond_signal (&vstfx->plugin_dispatcher_called);
 453                                 }
 454
 455                                 /*Call the editor Idle function in the plugin*/
 456
 457                                 vstfx->plugin->dispatcher (vstfx->plugin, effEditIdle, 0, 0, NULL, 0);
 458
 459                                 if(vstfx->wantIdle)
 460                                         vstfx->plugin->dispatcher (vstfx->plugin, 53, 0, 0, NULL, 0);
 461
 462                                 pthread_mutex_unlock (&vstfx->lock);
 463                         }
 464                         pthread_mutex_unlock (&plugin_mutex);
 465                 }
 466         }
 467
 468         /*Drop out to here if we set gui_quit to 1 */
 469
 470         return NULL;
 471 }
 472
 473 /*The VSTFX Init function - this needs to be called before the VSTFX engine
 474 can be accessed, it gets the UI thread running, opens a connection to X etc
 475 normally started in globals.cc*/
 476
 477 int vstfx_init (void* ptr)
 478 {
 479
 480         int thread_create_result;
 481
 482         pthread_attr_t thread_attributes;
 483
 484         /*Init the attribs to defaults*/
 485
 486         pthread_attr_init(&thread_attributes);
 487
 488         /*Make sure the thread is joinable - this should be the default anyway -
 489         so we can join to it on vstfx_exit*/
 490
 491         pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_JOINABLE);
 492
 493
 494         /*This is where we need to open a connection to X, and start the GUI thread*/
 495
 496         /*Open our connection to X - all linuxVST plugin UIs handled by the LXVST engine
 497         will talk to X down this connection - X cannot handle multi-threaded access via
 498         the same Display* */
 499
 500         if(LXVST_XDisplay==NULL)
 501                 LXVST_XDisplay = XOpenDisplay(NULL);    //We might be able to make this open a specific screen etc
 502
 503         /*Drop out and report the error if we fail to connect to X */
 504
 505         if(LXVST_XDisplay==NULL)
 506         {
 507                 vstfx_error ("** ERROR ** VSTFX: Failed opening connection to X");
 508
 509                 return -1;
 510         }
 511
 512         /*We have a connection to X - so start the gui event loop*/
 513
 514         /*Create the thread - use default attrs for now, don't think we need anything special*/
 515
 516         thread_create_result = pthread_create(&LXVST_gui_event_thread, NULL, gui_event_loop, NULL);
 517
 518         if(thread_create_result!=0)
 519         {
 520                 /*There was a problem starting the GUI event thread*/
 521
 522                 vstfx_error ("** ERROR ** VSTFX: Failed starting GUI event thread");
 523
 524                 XCloseDisplay(LXVST_XDisplay);
 525
 526                 return -1;
 527         }
 528
 529         return 0;
 530 }
 531
 532 /*The vstfx Quit function*/
 533
 534 void vstfx_exit()
 535 {
 536         gui_quit = 1;
 537
 538         /*We need to pthread_join the gui_thread here so
 539         we know when it has stopped*/
 540
 541         pthread_join(LXVST_gui_event_thread, NULL);
 542 }
 543
 544 /*Adds a new plugin (VSTFX) instance to the linked list*/
 545
 546 int vstfx_run_editor (VSTState* vstfx)
 547 {
 548         pthread_mutex_lock (&plugin_mutex);
 549
 550         /* Add the new VSTFX instance to the linked list */
 551
 552         if (vstfx_first == NULL) {
 553                 vstfx_first = vstfx;
 554         } else {
 555                 VSTState* p = vstfx_first;
 556
 557                 while (p->next) {
 558                         p = p->next;
 559                 }
 560                 p->next = vstfx;
 561
 562                 /* Mark the new end of the list */
 563
 564                 vstfx->next = NULL;
 565         }
 566
 567         pthread_mutex_unlock (&plugin_mutex);
 568
 569         /* wait for the plugin editor window to be created (or not) */
 570
 571         pthread_mutex_lock (&vstfx->lock);
 572
 573         if (!vstfx->linux_window) {
 574                 pthread_cond_wait (&vstfx->window_status_change, &vstfx->lock);
 575         }
 576
 577         pthread_mutex_unlock (&vstfx->lock);
 578
 579         if (!vstfx->linux_window) {
 580                 return -1;
 581         }
 582
 583         return 0;
 584 }
 585
 586
 587 /*Creates an editor for the plugin - normally called from within the gui event loop
 588 after run_editor has added the plugin (editor) to the linked list*/
 589
 590 int vstfx_create_editor (VSTState* vstfx)
 591 {
 592         Window parent_window;
 593
 594         int x_size = 1;
 595         int y_size = 1;
 596
 597         /* Note: vstfx->lock is held while this function is called */
 598
 599         if (!(vstfx->plugin->flags & effFlagsHasEditor))
 600         {
 601                 vstfx_error ("** ERROR ** VSTFX: Plugin \"%s\" has no editor", vstfx->handle->name);
 602                 return -1;
 603         }
 604
 605
 606         /*Create an XWindow for the plugin to inhabit*/
 607
 608         parent_window = XCreateSimpleWindow (
 609                 LXVST_XDisplay,
 610                 DefaultRootWindow(LXVST_XDisplay),
 611                 0,
 612                 0,
 613                 x_size,
 614                 y_size,
 615                 0,
 616                 0,
 617                 0
 618                 );
 619
 620         /*Select the events we are interested in receiving - we need Substructure notify so that
 621         if the plugin resizes its window - e.g. Loomer Manifold then we get a message*/
 622
 623         XSelectInput(LXVST_XDisplay,
 624                                 parent_window,
 625                                 SubstructureNotifyMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | ExposureMask);
 626
 627         vstfx->linux_window = parent_window;
 628
 629         vstfx->xid = parent_window;  //vstfx->xid will be referenced to connect to GTK UI in ardour later
 630
 631         /*Because the plugin may be operating on a different Display* to us, and therefore
 632         the two event queues can be asynchronous, although we have created the window on
 633         our display, we can't guarantee it exists in the server yet, which will
 634         cause BadWindow crashes if the plugin tries to use it.
 635
 636         It would be nice to use CreateNotify events here, but they don't get
 637         through on all window managers, so instead we pass a client message
 638         into out queue, after the XCreateWindow.  When this message pops out
 639         in our event handler, it will trigger the second stage of plugin
 640         Editor instantiation, and by then the Window should be valid...*/
 641
 642         XClientMessageEvent event;
 643
 644         /*Create an atom to identify our message (only if it doesn't already exist)*/
 645
 646         Atom WindowActiveAtom = XInternAtom(LXVST_XDisplay, "LaunchEditor", false);
 647
 648         event.type = ClientMessage;
 649         event.send_event = true;
 650         event.window = parent_window;
 651         event.message_type = WindowActiveAtom;
 652
 653         event.format = 32;                                              //Data format
 654         event.data.l[0] = 0x0FEEDBAC;                   //Something we can recognize later
 655
 656         /*Push the event into the queue on our Display*/
 657
 658         XSendEvent(LXVST_XDisplay, parent_window, FALSE, NoEventMask, (XEvent*)&event);
 659
 660         /*Unlock - and we are done for the first part of staring the Editor...*/
 661
 662         pthread_mutex_unlock (&vstfx->lock);
 663
 664         return 0;
 665 }
 666
 667 int
 668 vstfx_launch_editor (VSTState* vstfx)
 669 {
 670         /*This is the second stage of launching the editor (see vstfx_create editor)
 671         we get called here in response to receiving the ClientMessage on our Window,
 672         therefore it's about as safe (as can be) to assume that the Window we created
 673         is now valid in the XServer and can be passed to the plugin in effEditOpen
 674         without generating BadWindow errors when the plugin reparents itself into our
 675         parent window*/
 676
 677         if(vstfx->been_activated)
 678                 return 0;
 679
 680         Window parent_window;
 681         struct ERect* er;
 682
 683         int x_size = 1;
 684         int y_size = 1;
 685
 686         parent_window = vstfx->linux_window;
 687
 688         /*Open the editor - Bah! we have to pass the int windowID as a void pointer - yuck
 689         it gets cast back to an int as the parent window XID in the plugin - and we have to pass the
 690         Display* as a long */
 691
 692         /**************************************************************/
 693         /* 64Bit --- parent window is an int passed as a void* so     */
 694         /* that should be ok for 64Bit machines                       */
 695         /*                                                            */
 696         /* Display is passed in as a long - ok on arch's where sizeof */
 697         /* long = 8                                                   */
 698         /*                                                            */
 699         /* Most linux VST plugins open a connection to X on their own */
 700         /* Display anyway so it may not matter                        */
 701         /*                                                            */
 702         /* linuxDSP VSTs don't use the host Display* at all           */
 703         /**************************************************************/
 704
 705         vstfx->plugin->dispatcher (vstfx->plugin, effEditOpen, 0, (long)LXVST_XDisplay, (void*)(parent_window), 0 );
 706
 707         /*QUIRK - some plugins need a slight delay after opening the editor before you can
 708         ask the window size or they might return zero - specifically discoDSP */
 709
 710         Glib::usleep(100000);
 711
 712         /*Now we can find out how big the parent window should be (and try) to resize it*/
 713
 714         vstfx->plugin->dispatcher (vstfx->plugin, effEditGetRect, 0, 0, &er, 0 );
 715
 716         x_size = er->right - er->left;
 717         y_size = er->bottom - er->top;
 718
 719         vstfx->width =  x_size;
 720         vstfx->height =  y_size;
 721
 722         XResizeWindow(LXVST_XDisplay, parent_window, x_size, y_size);
 723
 724         XFlush (LXVST_XDisplay);
 725
 726         /*Not sure if we need to map the window or if the plugin will do it for us
 727         it should be ok because XReparentWindow generates a Map event*/
 728
 729         /*mark the editor as activated - mainly so that vstfx_get_XID
 730         will know it is valid*/
 731
 732         vstfx->been_activated = TRUE;
 733
 734         pthread_cond_signal (&vstfx->window_status_change);
 735         return 0;
 736 }
 737
 738 /** Destroy the editor window */
 739 void
 740 vstfx_destroy_editor (VSTState* vstfx)
 741 {
 742         pthread_mutex_lock (&vstfx->lock);
 743         if (vstfx->linux_window) {
 744                 vstfx->destroy = TRUE;
 745                 pthread_cond_wait (&vstfx->window_status_change, &vstfx->lock);
 746         }
 747         pthread_mutex_unlock (&vstfx->lock);
 748 }
 749
 750 /** Remove a vstfx instance from the linked list parsed by the
 751     event loop
 752 */
 753 void
 754 vstfx_event_loop_remove_plugin (VSTState* vstfx)
 755 {
 756         /* This only ever gets called from within our GUI thread
 757            so we don't need to lock here - if we did there would be
 758            a deadlock anyway
 759         */
 760
 761         VSTState* p;
 762         VSTState* prev;
 763
 764         for (p = vstfx_first, prev = NULL; p; prev = p, p = p->next) {
 765                 if (p == vstfx) {
 766                         if (prev) {
 767                                 prev->next = p->next;
 768                                 break;
 769                         }
 770                 }
 771         }
 772
 773         if (vstfx_first == vstfx) {
 774                 vstfx_first = vstfx_first->next;
 775         }
 776 }
 777