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