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