VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1180 Commits
4 Branches
540MB
Tree: d33071e5e2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd33071e5e2'
${ noResults }
Rack/dep/lglw/lglw_linux.c

2175 lines
71KB
Raw Blame History 

  1. /* ----

  2.  * ---- file   : lglw_linux.c  (**stub**)

  3.  * ---- author : bsp

  4.  * ---- legal  : Distributed under terms of the MIT LICENSE (MIT).

  5.  * ----

  6.  * ---- Permission is hereby granted, free of charge, to any person obtaining a copy

  7.  * ---- of this software and associated documentation files (the "Software"), to deal

  8.  * ---- in the Software without restriction, including without limitation the rights

  9.  * ---- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  10.  * ---- copies of the Software, and to permit persons to whom the Software is

  11.  * ---- furnished to do so, subject to the following conditions:

  12.  * ----

  13.  * ---- The above copyright notice and this permission notice shall be included in

  14.  * ---- all copies or substantial portions of the Software.

  15.  * ----

  16.  * ---- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  17.  * ---- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  18.  * ---- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  19.  * ---- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  20.  * ---- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  21.  * ---- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  22.  * ---- THE SOFTWARE.

  23.  * ----

  24.  * ---- info   : This is part of the "lglw" package.

  25.  * ----

  26.  * ---- created: 04Aug2018

  27.  * ---- changed: 05Aug2018, 06Aug2018, 07Aug2018, 08Aug2018, 09Aug2018, 18Aug2018, 10Oct2018, 16Oct2018

  28.  * ----

  29.  * ----

  30.  */

  31. 

  32. #include "lglw.h"

  33. 

  34. #include <stdlib.h>

  35. #include <stdio.h>

  36. #include <string.h>

  37. 

  38. #include <X11/Xlib.h>

  39. #include <X11/Xutil.h>

  40. #include <X11/Xos.h>

  41. 

  42. #include <GL/gl.h>

  43. #include <GL/glx.h>

  44. 

  45. #ifdef ARCH_X64

  46. #include <sys/mman.h>

  47. #include <unistd.h>

  48. #endif // ARCH_X64

  49. 

  50. #define Dprintf if(0);else printf

  51. // #define Dprintf if(1);else printf

  52. 

  53. #define Dprintf_verbose if(1);else printf

  54. // #define Dprintf_verbose if(0);else printf

  55. 

  56. #define Dlog_verbose if(1);else lglw_log

  57. // #define Dlog_verbose if(0);else lglw_log

  58. 

  59. // ---------------------------------------------------------------------------- macros and defines

  60. #define LGLW(a) lglw_int_t *lglw = ((lglw_int_t*)(a))

  61. 

  62. #define LGLW_DEFAULT_HIDDEN_W  (800)

  63. #define LGLW_DEFAULT_HIDDEN_H  (600)

  64. 

  65. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  66. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  67. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  68. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  69. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  70. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  71. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  72. 

  73. #define sABS(x) (((x)>0)?(x):-(x))

  74. 

  75. 

  76. // ---------------------------------------------------------------------------- structs and typedefs

  77. typedef struct lglw_int_s {

  78.    void        *user_data;    // arbitrary user data

  79.    Display     *xdsp;

  80.    XVisualInfo *vi;

  81.    Colormap     cmap;

  82.    Window       parent_xwnd;  // created by host

  83. 

  84.    struct {

  85.       lglw_vec2i_t size;

  86.       Window       xwnd;

  87.    } hidden;

  88. 

  89.    struct {

  90.       lglw_vec2i_t size;

  91.       Window       xwnd;

  92.       lglw_bool_t  mapped;

  93.       int32_t      swap_interval;

  94.       lglw_bool_t  b_owner;

  95.    } win;

  96. 

  97.    GLXContext   ctx;

  98. 

  99.    struct {

  100.       GLXContext   ctx;

  101.       GLXDrawable  drw;

  102.    } prev;

  103. 

  104.    struct {

  105.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  106.       lglw_keyboard_fxn_t cbk;

  107.    } keyboard;

  108. 

  109.    struct {

  110.       lglw_vec2i_t     p;  // last seen mouse position

  111.       uint32_t         button_state;

  112.       lglw_mouse_fxn_t cbk;

  113.       struct {

  114.          uint32_t         mode;

  115.          lglw_vec2i_t     p;  // grab-start mouse position

  116.          lglw_bool_t      b_queue_warp;

  117.          lglw_vec2i_t     last_p;

  118.       } grab;

  119.       struct {

  120.          lglw_bool_t      b_enable;

  121.          lglw_bool_t      b_update_queued;

  122.          lglw_bool_t      b_syn_rmb;

  123.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  124.          uint32_t         hold_start_ms;

  125.          lglw_vec2i_t     hold_start_p;

  126.       } touch;

  127.    } mouse;

  128. 

  129.    struct {

  130.       uint32_t         state;

  131.       lglw_focus_fxn_t cbk;

  132.    } focus;

  133. 

  134.    struct {

  135.       lglw_bool_t      b_running;

  136.       lglw_timer_fxn_t cbk;

  137.       struct timeval   tv_start;

  138.       uint32_t         interval_ms;

  139.       uint32_t         last_ms;

  140.    } timer;

  141. 

  142.    struct {

  143.       uint32_t numChars;

  144.       char *data;

  145.    } clipboard;

  146. 

  147.    struct {

  148.       lglw_dropfiles_fxn_t cbk;

  149.    } dropfiles;

  150. 

  151.    struct {

  152.       lglw_redraw_fxn_t cbk;

  153.    } redraw;

  154. 

  155. } lglw_int_t;

  156. 

  157. 

  158. // ---------------------------------------------------------------------------- module fxn fwd decls

  159. static lglw_bool_t loc_create_hidden_window (lglw_int_t *lglw, int32_t _w, int32_t _h);

  160. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  161. 

  162. static lglw_bool_t loc_handle_key (lglw_int_t *lglw, lglw_bool_t _bPressed, uint32_t _vkey);

  163. // static lglw_bool_t loc_touchkeyboard_get_rect (RECT *rect);

  164. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  165. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  166. 

  167. static void loc_handle_mouseleave (lglw_int_t *lglw);

  168. static void loc_handle_mouseenter (lglw_int_t *lglw);

  169. static void loc_handle_mousebutton (lglw_int_t *lglw, lglw_bool_t _bPressed, uint32_t _button);

  170. static void loc_handle_mousemotion (lglw_int_t *lglw);

  171. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  172. 

  173. static void loc_enable_dropfiles (lglw_int_t *lglw, lglw_bool_t _bEnable);

  174. 

  175. static void loc_eventProc (XEvent *xev, lglw_int_t *lglw);

  176. static void loc_XEventProc (void *_xevent);

  177. static void loc_setProperty (Display *_display, Window _window, const char *_name, void *_value);

  178. static void *loc_getProperty (Display *_display, Window _window, const char *_name);

  179. static void loc_setEventProc (Display *display, Window window);

  180. 

  181. static void loc_millisec_init (lglw_int_t *lglw);

  182. static uint32_t loc_millisec_delta (lglw_int_t *lglw);  // return millisec since init()

  183. static void loc_process_timer (lglw_int_t *lglw);

  184. 

  185. 

  186. // ---------------------------------------------------------------------------- lglw_millisec_init

  187. static void loc_millisec_init (lglw_int_t *lglw) {

  188.    gettimeofday(&lglw->timer.tv_start, 0);

  189. }

  190. 

  191. // ---------------------------------------------------------------------------- lglw_millisec_delta

  192. static uint32_t loc_millisec_delta (lglw_int_t *lglw) {

  193.    struct timeval c; gettimeofday(&c, 0);

  194.    const struct timeval*s =  &lglw->timer.tv_start;

  195.    return (uint32_t) ( (c.tv_sec-s->tv_sec)*1000 + (c.tv_usec-s->tv_usec)/1000 );

  196. }

  197. 

  198. 

  199. // TODO: remove and/or improve debug logging for a debug build

  200. // ---------------------------------------------------------------------------- lglw_log

  201. static FILE *logfile;

  202. 

  203. void lglw_log(const char *logData, ...) {

  204.    fprintf(logfile, logData);

  205.    fflush(logfile);

  206.    printf(logData);

  207. }

  208. 

  209. 

  210. // TODO: remove, or maybe not in some specific use cases

  211. // ---------------------------------------------------------------------------- xerror_log

  212. static int xerror_handler(Display *display, XErrorEvent *error) {

  213.    char error_text[1024];

  214.    XGetErrorText(display, error->error_code, error_text, 1024);

  215.    lglw_log("XERROR (%d): %s, %d, %d\n", error->error_code, error_text, error->request_code, error->minor_code);

  216.    return 0;

  217. }

  218. 

  219. 

  220. // ---------------------------------------------------------------------------- lglw_init

  221. lglw_t lglw_init(int32_t _w, int32_t _h) {

  222.    lglw_int_t *lglw = malloc(sizeof(lglw_int_t));

  223. 

  224.    printf("xxx lglw_init: sizeof(uint32_t)=%lu sizeof(long)=%lu sizeof(void*)=%lu\n", sizeof(uint32_t), sizeof(long), sizeof(void*));

  225. 

  226.    // TODO: remove/improve

  227.    logfile = fopen("/tmp/lglw_log.txt", "w");

  228.    XSetErrorHandler(xerror_handler);

  229.    XInitThreads();  // fix GL crash, see <https://forum.juce.com/t/linux-vst-opengl-crash-because-xinitthreads-not-called/22821>

  230.    

  231.    loc_millisec_init(lglw);

  232. 

  233.    if(NULL != lglw)

  234.    {

  235.       memset(lglw, 0, sizeof(lglw_int_t));

  236. 

  237.       lglw_log("lglw:lglw_init: 1\n");

  238.       if(_w <= 16)

  239.          _w = LGLW_DEFAULT_HIDDEN_W;

  240. 

  241.       if(_h <= 16)

  242.          _h = LGLW_DEFAULT_HIDDEN_H;

  243. 

  244.       lglw_log("lglw:lglw_init: 2\n");

  245.       if(!loc_create_hidden_window(lglw, _w, _h))

  246.       {

  247.          free(lglw);

  248.          lglw = NULL;

  249.       }

  250.       lglw_log("lglw:lglw_init: 3\n");

  251.    }

  252. 

  253.    lglw_log("lglw:lglw_init: EXIT\n");

  254. 

  255.    return lglw;

  256. }

  257. 

  258. 

  259. // ---------------------------------------------------------------------------- lglw_exit

  260. void lglw_exit(lglw_t _lglw) {

  261.    LGLW(_lglw);

  262. 

  263.    if(NULL != lglw)

  264.    {

  265.       lglw_log("lglw:lglw_exit: 1\n");

  266. 

  267.       loc_destroy_hidden_window(lglw);

  268. 

  269.       lglw_log("lglw:lglw_exit: 2\n");

  270. 

  271.       fclose(logfile);

  272.       free(lglw);

  273.    }

  274. }

  275. 

  276. 

  277. // ---------------------------------------------------------------------------- lglw_userdata_set

  278. void lglw_userdata_set(lglw_t _lglw, void *_userData) {

  279.    LGLW(_lglw);

  280. 

  281.    if(NULL != lglw)

  282.    {

  283.       // lglw_log("lglw:lglw_userdata_set: 1\n");

  284.       lglw->user_data = _userData;

  285.    }

  286. }

  287. 

  288. // ---------------------------------------------------------------------------- lglw_userdata_get

  289. void *lglw_userdata_get(lglw_t _lglw) {

  290.    LGLW(_lglw);

  291. 

  292.    if(NULL != lglw)

  293.    {

  294.       // lglw_log("lglw:lglw_userdata_get: 1\n");

  295.       return lglw->user_data;

  296.    }

  297. 

  298.    return NULL;

  299. }

  300. 

  301. 

  302. // ---------------------------------------------------------------------------- loc_create_hidden_window

  303. static lglw_bool_t loc_create_hidden_window(lglw_int_t *lglw, int32_t _w, int32_t _h) {

  304. 

  305.    // TODO: compare to 'WindowClass' from Windows implementation

  306. 

  307.    lglw_log("lglw:loc_create_hidden_window: 1\n");

  308.    XSetWindowAttributes swa;

  309.    int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, None };

  310.    int screen;

  311. 

  312.    lglw_log("lglw:loc_create_hidden_window: 2\n");

  313.    lglw->xdsp = XOpenDisplay(NULL);

  314.    screen = DefaultScreen(lglw->xdsp);

  315. 

  316.    lglw_log("lglw:loc_create_hidden_window: 3\n");

  317.    lglw->vi = glXChooseVisual(lglw->xdsp, screen, attrib);

  318. 

  319.    lglw_log("lglw:loc_create_hidden_window: 4\n");

  320.    if(NULL == lglw->vi)

  321.    {

  322.       lglw_log("[---] lglw: failed to find GLX Visual for hidden window\n");

  323.       return LGLW_FALSE;

  324.    }

  325. 

  326.    lglw_log("lglw:loc_create_hidden_window: 5\n");

  327.    lglw->ctx = glXCreateContext(lglw->xdsp, lglw->vi, None, True);

  328. 

  329.    lglw_log("lglw:loc_create_hidden_window: 6\n");

  330.    if(NULL == lglw->ctx)

  331.    {

  332.       lglw_log("[---] lglw: failed to create GLX Context for hidden window\n");

  333.       return LGLW_FALSE;

  334.    }

  335. 

  336.    lglw_log("lglw:loc_create_hidden_window: 7\n");

  337.    lglw->cmap = XCreateColormap(lglw->xdsp, RootWindow(lglw->xdsp, lglw->vi->screen),

  338.                                 lglw->vi->visual, AllocNone);

  339. 

  340.    lglw_log("lglw:loc_create_hidden_window: 8\n");

  341.    swa.border_pixel = 0;

  342.    swa.colormap = lglw->cmap;

  343.    lglw->hidden.xwnd = XCreateWindow(lglw->xdsp, DefaultRootWindow(lglw->xdsp),

  344.       0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

  345.       lglw->vi->visual, CWBorderPixel | CWColormap, &swa);

  346. 

  347.    lglw_log("lglw:loc_create_hidden_window: 9\n");

  348.    XSetStandardProperties(lglw->xdsp, lglw->hidden.xwnd, "LGLW_hidden", "LGLW_hidden", None, NULL, 0, NULL);

  349.    XSync(lglw->xdsp, False);

  350. 

  351.    lglw_log("lglw:loc_create_hidden_window: EXIT\n");

  352.    lglw->hidden.size.x = _w;

  353.    lglw->hidden.size.y = _h;

  354. 

  355.    return LGLW_TRUE;

  356. }

  357. 

  358. 

  359. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  360. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

  361.    lglw_log("lglw:loc_destroy_hidden_window: 1\n");

  362.    if(NULL != lglw->xdsp && NULL != lglw->ctx)

  363.    {

  364.       glXMakeCurrent(lglw->xdsp, None, NULL);

  365.       glXDestroyContext(lglw->xdsp, lglw->ctx);

  366.    }

  367.    lglw_log("lglw:loc_destroy_hidden_window: 2\n");

  368.    if(NULL != lglw->xdsp && 0 != lglw->hidden.xwnd) XDestroyWindow(lglw->xdsp, lglw->hidden.xwnd);

  369.    lglw_log("lglw:loc_destroy_hidden_window: 3\n");

  370.    if(NULL != lglw->xdsp && 0 != lglw->cmap) XFreeColormap(lglw->xdsp, lglw->cmap);

  371.    lglw_log("lglw:loc_destroy_hidden_window: 4\n");

  372.    if(NULL != lglw->vi) XFree(lglw->vi);

  373. 

  374.    lglw_log("lglw:loc_destroy_hidden_window: 5\n");

  375.    XSync(lglw->xdsp, False);

  376.    if(NULL != lglw->xdsp) XCloseDisplay(lglw->xdsp);

  377. }

  378. 

  379. 

  380. // ---------------------------------------------------------------------------- loc_setEventProc

  381. // https://www.kvraudio.com/forum/viewtopic.php?t=387924

  382. // https://github.com/Ardour/ardour/blob/master/gtk2_ardour/linux_vst_gui_support.cc

  383. // https://discourse.ardour.org/t/overtonedsp-plugins/90115/22

  384. // https://github.com/amsynth/amsynth/blob/4a87798e650c6d71d70274a961c9b8d98fc6da7e/src/amsynth_vst.cpp

  385. // https://github.com/rsenn/eXT2/blob/7f00a09561ded8175ffed2f4912dad74e466a1c7/vstplugins/vstgui/vstgui.cpp

  386. // https://github.com/COx2/DistortionFilter/blob/c6a34fb56b503a6e95bf0975e00f438bbf4ff52a/juce/modules/juce_audio_processors/format_types/juce_VSTPluginFormat.cpp

  387. 

  388. // Very simple function to test _XEventProc is properly called

  389. static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {

  390. 

  391.    Dlog_verbose("vstgltest<lglw_linux>: eventProc: type=%d serial=%lu send_event=%d lglw=%p\n", xev->xany.type, xev->xany.serial, xev->xany.send_event, lglw);

  392. 

  393.    loc_process_timer(lglw);

  394. 

  395.    if(NULL != lglw)

  396.    {

  397.       lglw_bool_t eventHandled = LGLW_FALSE;

  398. 

  399.       switch(xev->type)

  400.       {

  401.          default:

  402.             printf("vstgltest<lglw_linux>: unhandled X11 event type=%d\n", xev->type);

  403.             eventHandled = LGLW_FALSE;

  404.             break;

  405. 

  406.          case Expose:

  407.             Dlog_verbose("vstgltest<lglw_linux>: xev Expose\n");

  408.             loc_handle_queued_mouse_warp(lglw);

  409.             eventHandled = LGLW_FALSE;

  410.             if(NULL != lglw->redraw.cbk)

  411.             {

  412.                lglw->redraw.cbk(lglw);

  413.                eventHandled = LGLW_TRUE;

  414.             }

  415.             break;

  416. 

  417.             // TODO: Should FocusIn/Out be treated like WM_CAPTURECHANGED and reset the grab state?

  418. 

  419.          case FocusIn:

  420.             Dlog_verbose("vstgltest<lglw_linux>: xev FocusIn\n");

  421.             eventHandled = LGLW_FALSE;

  422.             break;

  423. 

  424.          case FocusOut:

  425.             Dlog_verbose("vstgltest<lglw_linux>: xev FocusOut\n");

  426.             eventHandled = LGLW_FALSE;

  427.             break;

  428. 

  429.          case EnterNotify:

  430.             // printf("vstgltest<lglw_linux>: xev XEnterWindowEvent\n");

  431.             ; // empty statement

  432.             XEnterWindowEvent *wenter = (XEnterWindowEvent*)xev;

  433.             printf("vstgltest<lglw_linux>: xev EnterNotify: mode:%i, detail:%i, state:%d\n", wenter->mode, wenter->detail, wenter->state);

  434.             lglw->mouse.p.x = wenter->x;

  435.             lglw->mouse.p.y = wenter->y;

  436.             loc_handle_mousemotion(lglw);

  437. 

  438.             // EnterNotify messages can be pseudo-motion events (NotifyGrab, NotifyUngrab)

  439.             // when buttons are pressed, which would trigger false focus changes

  440.             // so, the callback is only sent when a normal entry happens

  441.             if (wenter->mode == NotifyNormal)

  442.             {

  443.                loc_handle_mouseenter(lglw);

  444.             }

  445.             eventHandled = LGLW_TRUE;

  446. 

  447.             break;

  448. 

  449.          case LeaveNotify:

  450.             // printf("vstgltest<lglw_linux>: xev XLeaveWindowEvent\n");

  451.             ; // empty statement

  452.             XLeaveWindowEvent *wexit = (XLeaveWindowEvent*)xev;

  453.             printf("vstgltest<lglw_linux>: xev LeaveNotify: mode:%i, detail:%i, state:%d\n", wexit->mode, wexit->detail, wexit->state);

  454. 

  455.             // LeaveNotify messages can be pseudo-motion events (NotifyGrab, NotifyUngrab)

  456.             // when buttons are pressed, which would trigger false focus changes

  457.             // so, the callback is only sent when a normal entry happens

  458.             if (wexit->mode == NotifyNormal)

  459.             {

  460.                loc_handle_mouseleave(lglw);

  461.             }

  462.             eventHandled = LGLW_TRUE;

  463. 

  464.             break;

  465. 

  466.          case MotionNotify:

  467.             // printf("vstgltest<lglw_linux>: xev MotionNotify\n");

  468.             ; // empty statement

  469.             XMotionEvent *motion = (XMotionEvent*)xev;

  470. 

  471.             if(LGLW_MOUSE_GRAB_WARP == lglw->mouse.grab.mode)

  472.             {

  473.                lglw->mouse.grab.b_queue_warp = LGLW_TRUE;

  474. 

  475.                lglw->mouse.p.x += (motion->x - lglw->mouse.grab.last_p.x);

  476.                lglw->mouse.p.y += (motion->y - lglw->mouse.grab.last_p.y);

  477. 

  478.                lglw->mouse.grab.last_p.x = motion->x;

  479.                lglw->mouse.grab.last_p.y = motion->y;

  480.             }

  481.             else

  482.             {

  483.                lglw->mouse.p.x = motion->x;

  484.                lglw->mouse.p.y = motion->y;

  485.             }

  486. 

  487.             loc_handle_mousemotion(lglw);

  488.             eventHandled = LGLW_TRUE;

  489. 

  490.             break;

  491. 

  492.          case KeyPress:

  493.             printf("vstgltest<lglw_linux>: xev KeyPress\n");

  494.             XKeyPressedEvent *keyPress = (XKeyPressedEvent*)xev;

  495. 

  496.             eventHandled = LGLW_FALSE;

  497.             KeySym xkp = XLookupKeysym(keyPress, 0);

  498.             switch(xkp)

  499.             {

  500.                default:

  501.                   printf("vstgltest<lglw_linux>: xev KeyPress: %x or %lu\n", keyPress->keycode, xkp);

  502.                   if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT))

  503.                   {

  504.                      KeySym xkpl;

  505.                      KeySym xkpu;

  506.                      XConvertCase(xkp, &xkpl, &xkpu);

  507.                      eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, xkpu);

  508.                   }

  509.                   else

  510.                   {

  511.                      eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, xkp);

  512.                   }

  513.                   break;

  514. 

  515.                case NoSymbol:

  516.                   printf("vstgltest<lglw_linux>: xev UNKNOWN KeyPress: %x\n", keyPress->keycode);

  517.                   break;

  518. 

  519.                case XK_Left:

  520.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_LEFT);

  521.                   break;

  522. 

  523.                case XK_Right:

  524.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_RIGHT);

  525.                   break;

  526. 

  527.                case XK_Up:

  528.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_UP);

  529.                   break;

  530. 

  531.                case XK_Down:

  532.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_DOWN);

  533.                   break;

  534. 

  535.                case XK_Insert:

  536.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_INSERT);

  537.                   break;

  538. 

  539.                case XK_Delete:

  540.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_DELETE);

  541.                   break;

  542. 

  543.                case XK_Home:

  544.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_HOME);

  545.                   break;

  546. 

  547.                case XK_End:

  548.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_END);

  549.                   break;

  550. 

  551.                case XK_F1:

  552.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F1);

  553.                   break;

  554. 

  555.                case XK_F2:

  556.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F2);

  557.                   break;

  558. 

  559.                case XK_F3:

  560.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F3);

  561.                   break;

  562. 

  563.                case XK_F4:

  564.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F4);

  565.                   break;

  566. 

  567.                case XK_F5:

  568.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F5);

  569.                   break;

  570. 

  571.                case XK_F6:

  572.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F6);

  573.                   break;

  574. 

  575.                case XK_F7:

  576.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F7);

  577.                   break;

  578. 

  579.                case XK_F8:

  580.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F8);

  581.                   break;

  582. 

  583.                case XK_F9:

  584.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F9);

  585.                   break;

  586. 

  587.                case XK_F10:

  588.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F10);

  589.                   break;

  590. 

  591.                case XK_F11:

  592.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F11);

  593.                   break;

  594. 

  595.                case XK_F12:

  596.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_F12);

  597.                   break;

  598. 

  599.                case XK_BackSpace:

  600.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_BACKSPACE);

  601.                   break;

  602. 

  603.                case XK_Tab:

  604.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_TAB);

  605.                   break;

  606. 

  607.                case XK_Return:

  608.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_RETURN);

  609.                   break;

  610. 

  611.                case XK_Escape:

  612.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_ESCAPE);

  613.                   break;

  614. 

  615.                case XK_Shift_L:

  616.                   lglw->keyboard.kmod_state |= LGLW_KMOD_LSHIFT;

  617.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_LSHIFT);

  618.                   eventHandled = LGLW_FALSE;

  619.                   break;

  620. 

  621.                case XK_Shift_R:

  622.                   lglw->keyboard.kmod_state |= LGLW_KMOD_RSHIFT;

  623.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_RSHIFT);

  624.                   eventHandled = LGLW_FALSE;

  625.                   break;

  626. 

  627.                case XK_Control_L:

  628.                   lglw->keyboard.kmod_state |= LGLW_KMOD_LCTRL;

  629.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_KMOD_LCTRL);

  630.                   eventHandled = LGLW_FALSE;

  631.                   break;

  632. 

  633.                case XK_Control_R:

  634.                   lglw->keyboard.kmod_state |= LGLW_KMOD_RCTRL;

  635.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_KMOD_RCTRL);

  636.                   eventHandled = LGLW_FALSE;

  637.                   break;

  638.             }

  639. 

  640.             break;

  641. 

  642.          case KeyRelease:

  643.             printf("vstgltest<lglw_linux>: xev KeyRelease\n");

  644.             XKeyReleasedEvent *keyRelease = (XKeyReleasedEvent*)xev;

  645. 

  646.             eventHandled = LGLW_FALSE;

  647.             KeySym xkr = XLookupKeysym(keyRelease, 0);

  648.             switch(xkr)

  649.             {

  650.                default:

  651.                   printf("vstgltest<lglw_linux>: xev KeyRelease: %x or %lu\n", keyRelease->keycode, xkr);

  652.                   if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT))

  653.                   {

  654.                      KeySym xkrl;

  655.                      KeySym xkru;

  656.                      XConvertCase(xkr, &xkrl, &xkru);

  657.                      eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, xkru);

  658.                   }

  659.                   else

  660.                   {

  661.                      eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, xkr);

  662.                   }

  663.                   break;

  664. 

  665.                case NoSymbol:

  666.                   printf("vstgltest<lglw_linux>: xev UNKNOWN KeyRelease: %x\n", keyRelease->keycode);

  667.                   break;

  668. 

  669.                case XK_Left:

  670.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_LEFT);

  671.                   break;

  672. 

  673.                case XK_Right:

  674.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_RIGHT);

  675.                   break;

  676. 

  677.                case XK_Up:

  678.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_UP);

  679.                   break;

  680. 

  681.                case XK_Down:

  682.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_DOWN);

  683.                   break;

  684. 

  685.                case XK_Insert:

  686.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_INSERT);

  687.                   break;

  688. 

  689.                case XK_Delete:

  690.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_DELETE);

  691.                   break;

  692. 

  693.                case XK_Home:

  694.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_HOME);

  695.                   break;

  696. 

  697.                case XK_End:

  698.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_END);

  699.                   break;

  700. 

  701.                case XK_F1:

  702.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F1);

  703.                   break;

  704. 

  705.                case XK_F2:

  706.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F2);

  707.                   break;

  708. 

  709.                case XK_F3:

  710.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F3);

  711.                   break;

  712. 

  713.                case XK_F4:

  714.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F4);

  715.                   break;

  716. 

  717.                case XK_F5:

  718.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F5);

  719.                   break;

  720. 

  721.                case XK_F6:

  722.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F6);

  723.                   break;

  724. 

  725.                case XK_F7:

  726.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F7);

  727.                   break;

  728. 

  729.                case XK_F8:

  730.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F8);

  731.                   break;

  732. 

  733.                case XK_F9:

  734.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F9);

  735.                   break;

  736. 

  737.                case XK_F10:

  738.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F10);

  739.                   break;

  740. 

  741.                case XK_F11:

  742.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F11);

  743.                   break;

  744. 

  745.                case XK_F12:

  746.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_F12);

  747.                   break;

  748. 

  749.                case XK_BackSpace:

  750.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_BACKSPACE);

  751.                   break;

  752. 

  753.                case XK_Tab:

  754.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_TAB);

  755.                   break;

  756. 

  757.                case XK_Return:

  758.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_RETURN);

  759.                   break;

  760. 

  761.                case XK_Escape:

  762.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_ESCAPE);

  763.                   break;

  764. 

  765.                case XK_Shift_L:

  766.                   lglw->keyboard.kmod_state &= ~LGLW_KMOD_LSHIFT;

  767.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_LSHIFT);

  768.                   eventHandled = LGLW_FALSE;

  769.                   break;

  770. 

  771.                case XK_Shift_R:

  772.                   lglw->keyboard.kmod_state &= ~LGLW_KMOD_RSHIFT;

  773.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_RSHIFT);

  774.                   eventHandled = LGLW_FALSE;

  775.                   break;

  776. 

  777.                case XK_Control_L:

  778.                   lglw->keyboard.kmod_state &= ~LGLW_KMOD_LCTRL;

  779.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_LCTRL);

  780.                   eventHandled = LGLW_FALSE;

  781.                   break;

  782. 

  783.                case XK_Control_R:

  784.                   lglw->keyboard.kmod_state &= ~LGLW_KMOD_RCTRL;

  785.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_RCTRL);

  786.                   eventHandled = LGLW_FALSE;

  787.                   break;

  788.             }

  789. 

  790.             break;

  791. 

  792.          case ButtonPress:

  793.             printf("vstgltest<lglw_linux>: xev ButtonPress\n");

  794.             XButtonPressedEvent *btnPress = (XButtonPressedEvent*)xev;

  795.             lglw->mouse.p.x = btnPress->x;

  796.             lglw->mouse.p.y = btnPress->y;

  797. 

  798.             if(0u == (lglw->focus.state & LGLW_FOCUS_MOUSE))

  799.             {

  800.                loc_handle_mouseenter(lglw);

  801.             }

  802. 

  803.             switch(btnPress->button)

  804.             {

  805.                default:

  806.                   printf("vstgltest<lglw_linux>: xev ButtonPress unhandled button: %i\n", btnPress->button);

  807.                   eventHandled = LGLW_FALSE;

  808.                   break;

  809.                case Button1:

  810.                   loc_handle_mousebutton(lglw, LGLW_TRUE/*bPressed*/, LGLW_MOUSE_LBUTTON);

  811.                   eventHandled = LGLW_TRUE;

  812.                   break;

  813.                case Button2:

  814.                   loc_handle_mousebutton(lglw, LGLW_TRUE/*bPressed*/, LGLW_MOUSE_MBUTTON);

  815.                   eventHandled = LGLW_TRUE;

  816.                   break;

  817.                case Button3:

  818.                   loc_handle_mousebutton(lglw, LGLW_TRUE/*bPressed*/, LGLW_MOUSE_RBUTTON);

  819.                   eventHandled = LGLW_TRUE;

  820.                   break;

  821.                case Button4:

  822.                   loc_handle_mousebutton(lglw, LGLW_TRUE/*bPressed*/, LGLW_MOUSE_WHEELUP);

  823.                   eventHandled = LGLW_TRUE;

  824.                   break;

  825.                case Button5:

  826.                   loc_handle_mousebutton(lglw, LGLW_TRUE/*bPressed*/, LGLW_MOUSE_WHEELDOWN);

  827.                   eventHandled = LGLW_TRUE;

  828.                   break;

  829.             }

  830.             break;

  831. 

  832.          case ButtonRelease:

  833.             printf("vstgltest<lglw_linux>: xev ButtonRelease\n");

  834.             XButtonReleasedEvent *btnRelease = (XButtonReleasedEvent*)xev;

  835.             lglw->mouse.p.x = btnRelease->x;

  836.             lglw->mouse.p.y = btnRelease->y;

  837.             switch(btnRelease->button)

  838.             {

  839.                default:

  840.                   printf("vstgltest<lglw_linux>: xev ButtonRelease unhandled button: %i\n", btnRelease->button);

  841.                   eventHandled = LGLW_FALSE;

  842.                   break;

  843.                case Button1:

  844.                   loc_handle_mousebutton(lglw, LGLW_FALSE/*bPressed*/, LGLW_MOUSE_LBUTTON);

  845.                   eventHandled = LGLW_TRUE;

  846.                   break;

  847.                case Button2:

  848.                   loc_handle_mousebutton(lglw, LGLW_FALSE/*bPressed*/, LGLW_MOUSE_MBUTTON);

  849.                   eventHandled = LGLW_TRUE;

  850.                   break;

  851.                case Button3:

  852.                   loc_handle_mousebutton(lglw, LGLW_FALSE/*bPressed*/, LGLW_MOUSE_RBUTTON);

  853.                   eventHandled = LGLW_TRUE;

  854.                   break;

  855.                case Button4:

  856.                   loc_handle_mousebutton(lglw, LGLW_FALSE/*bPressed*/, LGLW_MOUSE_WHEELUP);

  857.                   eventHandled = LGLW_TRUE;

  858.                   break;

  859.                case Button5:

  860.                   loc_handle_mousebutton(lglw, LGLW_FALSE/*bPressed*/, LGLW_MOUSE_WHEELDOWN);

  861.                   eventHandled = LGLW_TRUE;

  862.                   break;

  863.             }

  864.             break;

  865. 

  866.          case SelectionClear:

  867.             printf("vstgltest<lglw_linux>: xev SelectionClear\n");

  868.             lglw->clipboard.numChars = 0;

  869.             free(lglw->clipboard.data);

  870.             eventHandled = LGLW_TRUE;

  871.             break;

  872. 

  873.          case SelectionRequest:

  874.             printf("vstgltest<lglw_linux>: xev SelectionRequest\n");

  875.             XSelectionRequestEvent *cbReq = (XSelectionRequestEvent*)xev;

  876.             XSelectionEvent cbRes;

  877. 

  878.             Atom utf8 = XInternAtom(lglw->xdsp, "UTF8_STRING", False);

  879. 

  880.             cbRes.type = SelectionNotify;

  881.             cbRes.requestor = cbReq->requestor;

  882.             cbRes.selection = cbReq->selection;

  883.             cbRes.target = cbReq->target;

  884.             cbRes.time = cbReq->time;

  885. 

  886.             if(cbReq->target == utf8)

  887.             {

  888.                XChangeProperty(lglw->xdsp, cbReq->requestor, cbReq->property, utf8, 8/*format*/, PropModeReplace,

  889.                                (unsigned char *)lglw->clipboard.data, lglw->clipboard.numChars);

  890. 

  891.                cbRes.property = cbReq->property;

  892.             }

  893.             else

  894.             {

  895.                cbRes.property = None;

  896.             }

  897. 

  898.             XSendEvent(lglw->xdsp, cbReq->requestor, True, NoEventMask, (XEvent *)&cbRes);

  899.             eventHandled = LGLW_TRUE;

  900. 

  901.             break;

  902.       }

  903. 

  904. #if 0

  905.       // (note) this causes a feedback loop in the VST2 debug host

  906.       if(LGLW_FALSE == eventHandled)

  907.       {

  908.          if(0 == lglw->parent_xwnd)

  909.          {

  910.             printf("lglw_linux:loc_eventProc: no parent window to send events to");

  911.             XSendEvent(lglw->xdsp, InputFocus, True/*propgate*/, NoEventMask, xev);

  912.          }

  913.          else

  914.          {

  915.             XSendEvent(lglw->xdsp, lglw->parent_xwnd, True/*propgate*/, NoEventMask, xev);

  916.          }

  917.       }

  918. #else

  919.       (void)eventHandled;

  920. #endif

  921.    }

  922. }

  923. 

  924. static void loc_XEventProc(void *_xevent) {

  925.    XEvent *xev = (XEvent*)_xevent;

  926. 

  927.    Dlog_verbose("XEventProc\n");

  928.    // printf("vstgltest<lglw_linux>: XEventProc, xev=%p\n", xev);

  929. 

  930.    if(NULL != xev)

  931.    {

  932.       LGLW(loc_getProperty(xev->xany.display, xev->xany.window, "_lglw"));  // get instance pointer

  933.       Dlog_verbose("lglw_linux:loc_XEventProc: xev=%p lglw=%p\n", xev, lglw);

  934. 

  935.       loc_eventProc(xev, lglw);

  936.    }

  937. }

  938. 

  939. static void loc_setProperty(Display *_display, Window _window, const char *_name, void *_value) {

  940.    size_t data = (size_t)_value;

  941.    long temp[2];

  942. 

  943.    // Split the 64 bit pointer into a little-endian long array

  944.    temp[0] = (long)(data & 0xffffffffUL);

  945.    temp[1] = (long)(data >> 32L);

  946. 

  947.    printf("xxx lglw_linux:loc_setProperty: name=\"%s\" value=%p temp[0]=%08x temp[1]=%08x\n", _name, _value, (uint32_t)temp[0], (uint32_t)temp[1]);

  948. 

  949.    Atom atom = XInternAtom(_display, _name, False/*only_if_exists*/);

  950. 

  951.    // (note) what's quite weird here is that we're writing an array of 32bit values, yet the element format must be 64bit (long)

  952.    XChangeProperty(_display, _window,

  953.                    atom/*property*/,

  954.                    atom/*type*/,

  955.                    32/*format*/,

  956.                    PropModeReplace/*mode*/,

  957.                    (unsigned char*)temp/*data*/,

  958.                    2/*nelements*/

  959.                    );

  960. }

  961. 

  962. static void *loc_getProperty(Display *_display, Window _window, const char *_name) {

  963.    int userSize;

  964.    unsigned long bytes;

  965.    unsigned long userCount;

  966.    unsigned char *data;

  967.    Atom userType;

  968.    Atom atom = XInternAtom(_display, _name, False);

  969. 

  970.    // (note) 64bit properties need to be read with two XGetWindowProperty() calls.

  971.    //         When using just one call and setting the 'length' to 2, the upper 32bit (second array element) will be 0xFFFFffff.

  972.    XGetWindowProperty(_display,

  973.                       _window,

  974.                       atom,

  975.                       0/*offset*/,

  976.                       1/*length*/,

  977.                       False/*delete*/,

  978.                       AnyPropertyType,

  979.                       &userType/*actual_type_return*/,

  980.                       &userSize/*actual_format_return*/,

  981.                       &userCount/*nitems_return*/,

  982.                       &bytes/*bytes_after_return / partial reads*/,

  983.                       &data);

  984. 

  985.    union {

  986.       uint32_t ui[2];

  987.       void *any;

  988.    } uptr;

  989.    uptr.any = 0;

  990. 

  991.    // printf("xxx lglw_linux: loc_getProperty: LOWER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);

  992. 

  993.    if(NULL != data)

  994.    {

  995.       if(userCount >= 1)

  996.       {

  997.          // if(userCount >= 2)

  998.          // {

  999.          //    printf("xxx loc_getProperty: lo=0x%08x hi=0x%08x\n", ((uint32_t*)data)[0], ((uint32_t*)data)[1]);

  1000.          // }

  1001. 

  1002.          // lower 32-bit

  1003.          uptr.ui[0] = *(long*)data;

  1004.          uptr.ui[1] = 0;

  1005. 

  1006.          // printf("xxx     lower=0x%08x\n", uptr.ui[0]);

  1007.          // // printf("xxx     upper=0x%08x\n", uptr.ui[1]);

  1008. 

  1009.          XFree(data);

  1010. 

  1011.          // // if(userCount >= 2)

  1012.          {

  1013.             XGetWindowProperty(_display,

  1014.                                _window,

  1015.                                atom,

  1016.                                1/*offset*/,

  1017.                                1/*length*/,

  1018.                                False/*delete*/,

  1019.                                AnyPropertyType,

  1020.                                &userType/*actual_type_return*/,

  1021.                                &userSize/*actual_format_return*/,

  1022.                                &userCount/*nitems_return*/,

  1023.                                &bytes/*bytes_after_return / partial reads*/,

  1024.                                &data);

  1025. 

  1026.             // printf("xxx lglw_linux: loc_getProperty: UPPER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);

  1027.             if(NULL != data)

  1028.             {

  1029.                // upper 32-bit

  1030.                uptr.ui[1] = *(long*)data;

  1031.                // printf("xxx     upper=0x%08x\n", uptr.ui[1]);

  1032.                XFree(data);

  1033.             }

  1034.          }

  1035.       }

  1036.    }

  1037. 

  1038.    // printf("xxx lglw_linux: loc_getProperty: return value=%p\n", uptr.any);

  1039. 

  1040.    return uptr.any;

  1041. }

  1042. 

  1043. 

  1044. #ifdef ARCH_X64

  1045. #if 0

  1046. // Pulled from the Renoise 64-bit callback example

  1047. // Unsure what data was supposed to be, but swapping it to a function name did not work

  1048. // This does nothing, no event proc found

  1049. static void loc_setEventProc (Display *display, Window window) {

  1050.    size_t data = (size_t)loc_eventProc;

  1051.    long temp[2];

  1052. 

  1053.    printf("vstgltest<lglw_linux>: setEventProc (2*32bit). window=%lu loc_eventProc=%p\n", window, &loc_eventProc);

  1054. 

  1055.    // Split the 64 bit pointer into a little-endian unsigned int array

  1056.    temp[0] = (uint32_t)(data & 0xffffffffUL);

  1057.    temp[1] = (uint32_t)(data >> 32L);

  1058. 

  1059.    Atom atom = XInternAtom(display, "_XEventProc", False);

  1060.    XChangeProperty(display, window,

  1061.                    atom/*property*/,

  1062.                    atom/*type*/,

  1063.                    32/*format*/,

  1064.                    PropModeReplace/*mode*/,

  1065.                    (unsigned char*)temp/*data*/,

  1066.                    2/*nelements*/

  1067.                    );

  1068. }

  1069. #else

  1070. // GPL code pulled from the amsynth example <https://github.com/amsynth/amsynth/blob/4a87798e650c6d71d70274a961c9b8d98fc6da7e/src/amsynth_vst.cpp>

  1071. // Simply swapped out the function names, crashes Ardour in the same was as the others

  1072. static void loc_setEventProc (Display *display, Window window) {

  1073.    //

  1074.    // JUCE calls XGetWindowProperty with long_length = 1 which means it only fetches the lower 32 bits of the address.

  1075.    // Therefore we need to ensure we return an address in the lower 32-bits of address space.

  1076.    //

  1077. 

  1078.    // based on mach_override

  1079.    static const unsigned char kJumpInstructions[] = {

  1080.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  1081.          0x00, 0x00, 0x00, 0x00,

  1082.          0x00, 0x00, 0x00, 0x00

  1083.    };

  1084.    static const int kJumpAddress = 6;

  1085. 

  1086.    static char *ptr = 0;

  1087.    if (!ptr) {

  1088.       ptr = (char *)mmap(0,

  1089.                          getpagesize()/*PAGE_SIZE*/,

  1090.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  1091.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  1092.                          0, 0);

  1093.       if (ptr == MAP_FAILED) {

  1094.          perror("mmap");

  1095.          ptr = 0;

  1096.          return;

  1097.       } else {

  1098.          memcpy(ptr, kJumpInstructions, sizeof(kJumpInstructions));

  1099.          *((uint64_t *)(ptr + kJumpAddress)) = (uint64_t)(&loc_XEventProc);

  1100.          msync(ptr, sizeof(kJumpInstructions), MS_INVALIDATE);

  1101.          printf("vstgltest<lglw_linux>: 64bit trampoline installed\n");

  1102.       }

  1103.    }

  1104. 

  1105.    long temp[2] = {(uint32_t)(((size_t)ptr)&0xFFFFfffful), 0};

  1106.    Atom atom = XInternAtom(display, "_XEventProc", False);

  1107.    XChangeProperty(display, window,

  1108.                    atom/*property*/,

  1109.                    atom/*type*/,

  1110.                    32/*format*/,

  1111.                    PropModeReplace/*mode*/,

  1112.                    (unsigned char *)temp/*data*/,

  1113.                    2/*nelements*/

  1114.                    );

  1115. }

  1116. #endif

  1117. #else

  1118. // Pulled from the eXT2 example

  1119. static void loc_setEventProc (Display *display, Window window) {

  1120.    void* data = (void*)&loc_XEventProc; // swapped the function name here

  1121. 

  1122.    // (note) 32-bit only

  1123.    Atom atom = XInternAtom(display, "_XEventProc", False);

  1124.    XChangeProperty(display, window,

  1125.                    atom/*property*/,

  1126.                    atom/*type*/,

  1127.                    32/*format*/,

  1128.                    PropModeReplace/*mode*/,

  1129.                    (unsigned char*)&data/*data*/,

  1130.                    1/*nelements*/

  1131.                    );

  1132. }

  1133. #endif // ARCH_X64

  1134. 

  1135. 

  1136. // ---------------------------------------------------------------------------- lglw_window_open

  1137. lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x, int32_t _y, int32_t _w, int32_t _h) {

  1138.    lglw_bool_t r = LGLW_FALSE;

  1139.    LGLW(_lglw);

  1140. 

  1141.    if(NULL != lglw)

  1142.    {

  1143.       lglw_log("lglw:lglw_window_open: 1, %p, %i \n", (Window)_parentHWNDOrNull, (Window)_parentHWNDOrNull);

  1144.       lglw->parent_xwnd = (0 == _parentHWNDOrNull) ? DefaultRootWindow(lglw->xdsp) : (Window)_parentHWNDOrNull;

  1145. 

  1146.       lglw_log("lglw:lglw_window_open: 2 lglw=%p\n", lglw);

  1147.       if(_w <= 16)

  1148.          _w = lglw->hidden.size.x;

  1149. 

  1150.       lglw_log("lglw:lglw_window_open: 3\n");

  1151.       if(_h <= 16)

  1152.          _h = lglw->hidden.size.y;

  1153. 

  1154.       // TODO: compare to 'WindowClass' from Windows implementation

  1155. 

  1156.       lglw_log("lglw:lglw_window_open: 4\n");

  1157.       XSetWindowAttributes swa;

  1158.       // // XEvent event;

  1159.       XSync(lglw->xdsp, False);

  1160. 

  1161. #if 1

  1162.       lglw_log("lglw:lglw_window_open: 5\n");

  1163.       swa.border_pixel = 0;

  1164.       swa.colormap = lglw->cmap;

  1165.       // (note) [bsp] setting this to NoEventMask causes all events to be propagated to the parent (host) window.

  1166.       //               The host then reports the event to the plugin by calling its eventProc function (set via "_XEventProc").

  1167.       swa.event_mask = NoEventMask;/////ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask | FocusChangeMask;

  1168.       lglw->win.xwnd = XCreateWindow(lglw->xdsp/*display*/,

  1169.                                      DefaultRootWindow(lglw->xdsp)/*parent. see Cameron's comment below.*/,

  1170.                                      0/*x*/,

  1171.                                      0/*y*/,

  1172.                                      _w/*width*/,

  1173.                                      _h/*height*/,

  1174.                                      0/*border_width*/,

  1175.                                      CopyFromParent/*depth*/,

  1176.                                      InputOutput/*class*/,

  1177.                                      lglw->vi->visual,

  1178.                                      CWBorderPixel | CWColormap | CWEventMask/*value_mask*/,

  1179.                                      &swa/*attributes*/

  1180.                                      );

  1181. 

  1182.       lglw_log("lglw:lglw_window_open: 6\n");

  1183.       XSetStandardProperties(lglw->xdsp/*display*/,

  1184.                              lglw->win.xwnd/*window*/,

  1185.                              "LGLW"/*window_name*/,

  1186.                              "LGLW"/*icon_name*/,

  1187.                              None/*icon_pixmap*/,

  1188.                              NULL/*argv*/,

  1189.                              0/*argc*/,

  1190.                              NULL/*XSizeHints*/

  1191.                              );

  1192. 

  1193.       // Setup the event proc now, on the parent window as well just for the debug host

  1194.       // It was simpler to do this than check in the debug host for the reparent event

  1195.       lglw_log("lglw:lglw_window_open: 7\n");

  1196.       loc_setEventProc(lglw->xdsp, lglw->win.xwnd);

  1197.       loc_setProperty(lglw->xdsp, lglw->win.xwnd, "_lglw", (void*)lglw);  // set instance pointer

  1198. 

  1199.       if(0 != _parentHWNDOrNull)

  1200.       {

  1201.          loc_setEventProc(lglw->xdsp, lglw->parent_xwnd);

  1202.          loc_setProperty(lglw->xdsp, lglw->parent_xwnd, "_lglw", (void*)lglw);  // set instance pointer

  1203.       }

  1204. 

  1205.       // Some hosts only check and store the callback when the Window is reparented

  1206.       // Since creating the Window with a Parent may or may not do that, but the callback is not set,

  1207.       // ... it's created as a root window, the callback is set, and then it's reparented

  1208. #if 1

  1209.       // (note) [cameronleger] In Ardour's code-base, the only time it looks for the _XEventProc is during a ReparentNotify event

  1210.       if (0 != _parentHWNDOrNull)

  1211.       {

  1212.          lglw_log("lglw:lglw_window_open: 8\n");

  1213.          XReparentWindow(lglw->xdsp, lglw->win.xwnd, lglw->parent_xwnd, 0, 0);

  1214.       }

  1215. #endif

  1216.       lglw->win.b_owner = LGLW_TRUE;

  1217. #else

  1218.       lglw->win.xwnd = (Window)_parentHWNDOrNull;

  1219.       lglw->win.b_owner = LGLW_FALSE;

  1220. #endif

  1221. 

  1222.       lglw_log("lglw:lglw_window_open: 9\n");

  1223.       if(lglw->win.b_owner)

  1224.       {

  1225.          // // XMapRaised(lglw->xdsp, lglw->win.xwnd);

  1226.          XMapWindow(lglw->xdsp, lglw->win.xwnd);

  1227.       }

  1228. 

  1229. #if 0

  1230.       XSelectInput(lglw->xdsp, lglw->win.xwnd,

  1231.                    ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask | FocusChangeMask

  1232.                    );

  1233.       XGrabKeyboard(lglw->xdsp, lglw->win.xwnd,

  1234.                     False/*owner_events*/,

  1235.                     GrabModeAsync/*pointer_mode*/,

  1236.                     GrabModeAsync/*keyboard_mode*/,

  1237.                     CurrentTime/*time*/

  1238.                     );

  1239. #endif

  1240. 

  1241. #if 0

  1242.       XSetInputFocus(lglw->xdsp/*display*/,

  1243.                      PointerRoot/*focus*/,

  1244.                      RevertToPointerRoot/*revert_to*/,

  1245.                      CurrentTime

  1246.                      );

  1247. #endif

  1248. 

  1249.       XSync(lglw->xdsp, False);

  1250.       lglw->win.mapped = LGLW_TRUE;

  1251. 

  1252.       lglw_log("lglw:lglw_window_open: 10\n");

  1253.       lglw->win.size.x = _w;

  1254.       lglw->win.size.y = _h;

  1255. 

  1256.       lglw_log("lglw:lglw_window_open: 11\n");

  1257.       loc_enable_dropfiles(lglw, (NULL != lglw->dropfiles.cbk));

  1258. 

  1259.       lglw_log("lglw:lglw_window_open: EXIT\n");

  1260. 

  1261.       r = LGLW_TRUE;

  1262.    }

  1263.    return r;

  1264. }

  1265. 

  1266. 

  1267. // ---------------------------------------------------------------------------- lglw_window_resize

  1268. lglw_bool_t lglw_window_resize (lglw_t _lglw, int32_t _w, int32_t _h) {

  1269.    lglw_bool_t r = LGLW_FALSE;

  1270.    LGLW(_lglw);

  1271. 

  1272.    if(NULL != lglw)

  1273.    {

  1274.       if(0 != lglw->win.xwnd)

  1275.       {

  1276.          lglw_log("lglw:lglw_window_resize: 1\n");

  1277.          r = LGLW_TRUE;

  1278. 

  1279.          lglw_log("lglw:lglw_window_resize: 2\n");

  1280.          XResizeWindow(lglw->xdsp, lglw->win.xwnd, _w, _h);

  1281.          XRaiseWindow(lglw->xdsp, lglw->win.xwnd);

  1282. 

  1283.          lglw_log("lglw:lglw_window_resize: 3\n");

  1284.          int deltaW = _w - lglw->win.size.x;

  1285.          int deltaH = _h - lglw->win.size.y;

  1286. 

  1287.          lglw_log("lglw:lglw_window_resize: 4\n");

  1288.          lglw->win.size.x = _w;

  1289.          lglw->win.size.y = _h;

  1290. 

  1291.          lglw_log("lglw:lglw_window_resize: 5\n");

  1292.          Window root, parent, *children = NULL;

  1293.          unsigned int num_children;

  1294. 

  1295.          lglw_log("lglw:lglw_window_resize: 6\n");

  1296.          if(!XQueryTree(lglw->xdsp, lglw->win.xwnd, &root, &parent, &children, &num_children))

  1297.             return r;

  1298. 

  1299.          lglw_log("lglw:lglw_window_resize: 7\n");

  1300.          if(children)

  1301.             XFree((char *)children);

  1302. 

  1303.          lglw_log("lglw:lglw_window_resize: 8\n");

  1304.          // Resize parent window (if any)

  1305.          if(0 != parent)

  1306.          {

  1307.             lglw_log("lglw:lglw_window_resize: 8.1\n");

  1308.             int x, y;

  1309.             unsigned int width, height;

  1310.             unsigned int border_width;

  1311.             unsigned int depth;

  1312. 

  1313.             lglw_log("lglw:lglw_window_resize: 8.2\n");

  1314.             if(!XGetGeometry(lglw->xdsp, lglw->win.xwnd, &root, &x, &y, &width, &height, &border_width, &depth))

  1315.                return r;

  1316. 

  1317.             lglw_log("lglw:lglw_window_resize: 8.3\n");

  1318.             XResizeWindow(lglw->xdsp, parent, width + deltaW, height + deltaH);

  1319.          }

  1320.          lglw_log("lglw:lglw_window_resize: EXIT\n");

  1321.       }

  1322.    }

  1323. 

  1324.    return r;

  1325. }

  1326. 

  1327. 

  1328. // ---------------------------------------------------------------------------- lglw_window_close

  1329. void lglw_window_close (lglw_t _lglw) {

  1330.    LGLW(_lglw);

  1331. 

  1332.    if(NULL != lglw)

  1333.    {

  1334.       if(0 != lglw->win.xwnd)

  1335.       {

  1336.          lglw_log("lglw:lglw_window_close: 1\n");

  1337.          lglw_timer_stop(_lglw);

  1338. 

  1339.          lglw_log("lglw:lglw_window_close: 2\n");

  1340.          glXMakeCurrent(lglw->xdsp, None, NULL);

  1341. 

  1342.          lglw_log("lglw:lglw_window_close: 3\n");

  1343.          if(lglw->win.b_owner)

  1344.          {

  1345.             XDestroyWindow(lglw->xdsp, lglw->win.xwnd);

  1346.             lglw->win.b_owner = LGLW_FALSE;

  1347.          }

  1348.          XSync(lglw->xdsp, False);

  1349.          lglw->win.xwnd = 0;

  1350.          lglw->win.mapped = LGLW_FALSE;

  1351.       }

  1352.    }

  1353.    lglw_log("lglw:lglw_window_close: EXIT\n");

  1354. }

  1355. 

  1356. 

  1357. // ---------------------------------------------------------------------------- lglw_window_show

  1358. void lglw_window_show(lglw_t _lglw) {

  1359.    LGLW(_lglw);

  1360. 

  1361.    if(NULL != lglw)

  1362.    {

  1363.       lglw_log("lglw:lglw_window_show: 1\n");

  1364.       XMapRaised(lglw->xdsp, lglw->win.xwnd);

  1365. 

  1366.       lglw->win.mapped = LGLW_TRUE;

  1367.    }

  1368.    lglw_log("lglw:lglw_window_show: EXIT\n");

  1369. }

  1370. 

  1371. 

  1372. // ---------------------------------------------------------------------------- lglw_window_hide

  1373. void lglw_window_hide(lglw_t _lglw) {

  1374.    LGLW(_lglw);

  1375. 

  1376.    if(NULL != lglw)

  1377.    {

  1378.       lglw_log("lglw:lglw_window_hide: 1\n");

  1379.       XUnmapWindow(lglw->xdsp, lglw->win.xwnd);

  1380. 

  1381.       lglw->win.mapped = LGLW_FALSE;

  1382.    }

  1383.    lglw_log("lglw:lglw_window_hide: EXIT\n");

  1384. }

  1385. 

  1386. 

  1387. // ---------------------------------------------------------------------------- lglw_window_is_visible

  1388. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  1389.    lglw_bool_t r = LGLW_FALSE;

  1390.    LGLW(_lglw);

  1391. 

  1392.    // lglw_log("lglw:lglw_window_is_visible: 1\n");

  1393.    if(NULL != lglw && 0 != lglw->win.xwnd)

  1394.    {

  1395.       // lglw_log("lglw:lglw_window_is_visible: 2\n");

  1396.       r = lglw->win.mapped;

  1397.    }

  1398. 

  1399.    // lglw_log("lglw:lglw_window_is_visible: EXIT\n");

  1400.    return r;

  1401. }

  1402. 

  1403. 

  1404. // ---------------------------------------------------------------------------- lglw_window_size_get

  1405. void lglw_window_size_get(lglw_t _lglw, int32_t *_retX, int32_t *_retY) {

  1406.    LGLW(_lglw);

  1407. 

  1408.    Dlog_verbose("lglw:lglw_window_size_get: 1\n");

  1409.    if(NULL != lglw)

  1410.    {

  1411.       if(0 != lglw->win.xwnd)

  1412.       {

  1413.          if(NULL != _retX)

  1414.             *_retX = lglw->win.size.x;

  1415. 

  1416.          if(NULL != _retY)

  1417.             *_retY = lglw->win.size.y;

  1418.       }

  1419.    }

  1420.    Dlog_verbose("lglw:lglw_window_size_get: EXIT\n");

  1421. }

  1422. 

  1423. 

  1424. // ---------------------------------------------------------------------------- lglw_redraw

  1425. void lglw_redraw(lglw_t _lglw) {

  1426.    LGLW(_lglw);

  1427. 

  1428.    // (todo) implement me

  1429. 

  1430.    if(NULL != lglw)

  1431.    {

  1432.       if(0 != lglw->win.xwnd)

  1433.       {

  1434.          // TODO Event Loop

  1435.          Dlog_verbose("lglw:lglw_redraw: 1\n");

  1436.          XEvent xev;

  1437.          xev.xany.type       = Expose;

  1438.          xev.xany.serial     = 0;

  1439.          xev.xany.send_event = True;

  1440.          xev.xany.display    = lglw->xdsp;

  1441.          xev.xany.window     = lglw->win.xwnd;

  1442.          xev.xexpose.x      = 0;

  1443.          xev.xexpose.y      = 0;

  1444.          xev.xexpose.width  = lglw->win.size.x;

  1445.          xev.xexpose.height = lglw->win.size.y;

  1446.          xev.xexpose.count  = 0;

  1447.          XSendEvent(lglw->xdsp, lglw->win.xwnd,

  1448.                     True/*propagate*/,

  1449.                     ExposureMask/*event_mask*/,

  1450.                     &xev

  1451.                     );

  1452.          XFlush(lglw->xdsp);

  1453.       }

  1454.    }

  1455. }

  1456. 

  1457. 

  1458. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

  1459. void lglw_redraw_callback_set(lglw_t _lglw, lglw_redraw_fxn_t _cbk) {

  1460.    LGLW(_lglw);

  1461. 

  1462.    if(NULL != lglw)

  1463.    {

  1464.       lglw->redraw.cbk = _cbk;

  1465.    }

  1466. }

  1467. 

  1468. 

  1469. // ---------------------------------------------------------------------------- lglw_glcontext_push

  1470. void lglw_glcontext_push(lglw_t _lglw) {

  1471.    LGLW(_lglw);

  1472. 

  1473.    if(NULL != lglw)

  1474.    {

  1475.       lglw->prev.drw = glXGetCurrentDrawable();

  1476.       lglw->prev.ctx = glXGetCurrentContext();

  1477. 

  1478.       // lglw_log("lglw:lglw_glcontext_push: win.xwnd=%p hidden.xwnd=%p ctx=%p\n",

  1479.       //    lglw->win.xwnd, lglw->hidden.xwnd, lglw->ctx);

  1480.       if(!glXMakeCurrent(lglw->xdsp, (0 == lglw->win.xwnd) ? lglw->hidden.xwnd : lglw->win.xwnd, lglw->ctx))

  1481.       {

  1482.          lglw_log("[---] lglw_glcontext_push: glXMakeCurrent() failed. win.xwnd=%p hidden.xwnd=%p ctx=%p glGetError()=%d\n", lglw->win.xwnd, lglw->hidden.xwnd, lglw->ctx, glGetError());

  1483.       }

  1484.    }

  1485. }

  1486. 

  1487. 

  1488. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  1489. void lglw_glcontext_pop(lglw_t _lglw) {

  1490.    LGLW(_lglw);

  1491. 

  1492.    if(NULL != lglw)

  1493.    {

  1494.       // lglw_log("lglw:lglw_glcontext_pop: prev.drw=%p prev.ctx=%p\n",

  1495.       //    lglw->prev.drw, lglw->prev.ctx);

  1496.       if(!glXMakeCurrent(lglw->xdsp, lglw->prev.drw, lglw->prev.ctx))

  1497.       {

  1498.          lglw_log("[---] lglw_glcontext_pop: glXMakeCurrent() failed. prev.drw=%p ctx=%p glGetError()=%d\n", lglw->prev.drw, lglw->prev.ctx, glGetError());

  1499.       }

  1500.    }

  1501. }

  1502. 

  1503. 

  1504. // ---------------------------------------------------------------------------- lglw_swap_buffers

  1505. void lglw_swap_buffers(lglw_t _lglw) {

  1506.    LGLW(_lglw);

  1507. 

  1508.    if(NULL != lglw)

  1509.    {

  1510.       if(0 != lglw->win.xwnd)

  1511.       {

  1512.          // lglw_log("lglw:lglw_swap_buffers: 1\n");

  1513.          glXSwapBuffers(lglw->xdsp, lglw->win.xwnd);

  1514.       }

  1515.    }

  1516. }

  1517. 

  1518. 

  1519. // ---------------------------------------------------------------------------- lglw_swap_interval_set

  1520. typedef void (APIENTRY *PFNWGLEXTSWAPINTERVALPROC) (Display *, GLXDrawable, int);

  1521. void lglw_swap_interval_set(lglw_t _lglw, int32_t _ival) {

  1522.    LGLW(_lglw);

  1523. 

  1524.    if(NULL != lglw)

  1525.    {

  1526.       if(0 != lglw->win.xwnd)

  1527.       {

  1528.          lglw_log("lglw:lglw_swap_interval_set: 1\n");

  1529.          PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

  1530.          glXSwapIntervalEXT = (PFNWGLEXTSWAPINTERVALPROC) glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");

  1531.          if(NULL != glXSwapIntervalEXT)

  1532.          {

  1533.             lglw_log("lglw:lglw_swap_interval_set: 2\n");

  1534.             glXSwapIntervalEXT(lglw->xdsp, lglw->win.xwnd, _ival);

  1535.             lglw->win.swap_interval = _ival;

  1536.          }

  1537.       }

  1538.    }

  1539. }

  1540. 

  1541. 

  1542. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  1543. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  1544.    LGLW(_lglw);

  1545.    int32_t r = 0;

  1546. 

  1547.    if(NULL != lglw)

  1548.    {

  1549.       r = lglw->win.swap_interval;

  1550.    }

  1551. 

  1552.    return r;

  1553. }

  1554. 

  1555. 

  1556. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  1557. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  1558.    lglw->focus.state &= ~LGLW_FOCUS_MOUSE;

  1559. 

  1560.    if(NULL != lglw->focus.cbk)

  1561.    {

  1562.       lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE);

  1563.    }

  1564. 

  1565.    lglw_log("xxx lglw:loc_handle_mouseleave: LEAVE\n");

  1566. }

  1567. 

  1568. 

  1569. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  1570. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  1571. 

  1572.    lglw->focus.state |= LGLW_FOCUS_MOUSE;

  1573. 

  1574.    if(NULL != lglw->focus.cbk)

  1575.    {

  1576.       lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE);

  1577.    }

  1578. 

  1579.    lglw_log("xxx lglw:loc_handle_mouseenter: LEAVE\n");

  1580. }

  1581. 

  1582. 

  1583. // ---------------------------------------------------------------------------- loc_handle_mousebutton

  1584. static void loc_handle_mousebutton(lglw_int_t *lglw, lglw_bool_t _bPressed, uint32_t _button) {

  1585.    if(_bPressed)

  1586.       lglw->mouse.button_state |= _button;

  1587.    else

  1588.       lglw->mouse.button_state &= ~_button;

  1589. 

  1590.    if(NULL != lglw->mouse.cbk)

  1591.    {

  1592.       lglw->mouse.cbk(lglw, lglw->mouse.p.x, lglw->mouse.p.y, lglw->mouse.button_state, _button);

  1593.    }

  1594. }

  1595. 

  1596. 

  1597. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  1598. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  1599. 

  1600.    if(NULL != lglw->mouse.cbk)

  1601.    {

  1602.       lglw->mouse.cbk(lglw, lglw->mouse.p.x, lglw->mouse.p.y, lglw->mouse.button_state, 0u/*changedbuttonstate*/);

  1603.    }

  1604. }

  1605. 

  1606. 

  1607. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

  1608. void lglw_mouse_callback_set(lglw_t _lglw, lglw_mouse_fxn_t _cbk) {

  1609.    LGLW(_lglw);

  1610. 

  1611.    if(NULL != lglw)

  1612.    {

  1613.       lglw->mouse.cbk = _cbk;

  1614.    }

  1615. }

  1616. 

  1617. 

  1618. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

  1619. void lglw_focus_callback_set(lglw_t _lglw, lglw_focus_fxn_t _cbk) {

  1620.    LGLW(_lglw);

  1621. 

  1622.    if(NULL != lglw)

  1623.    {

  1624.       lglw->focus.cbk = _cbk;

  1625.    }

  1626. }

  1627. 

  1628. 

  1629. // ---------------------------------------------------------------------------- loc_handle_key

  1630. static lglw_bool_t loc_handle_key(lglw_int_t *lglw, lglw_bool_t _bPressed, uint32_t _vkey) {

  1631.    lglw_bool_t r = LGLW_FALSE;

  1632. 

  1633.    if(NULL != lglw->keyboard.cbk)

  1634.    {

  1635.       r = lglw->keyboard.cbk(lglw, _vkey, lglw->keyboard.kmod_state, _bPressed);

  1636.    }

  1637. 

  1638.    return r;

  1639. }

  1640. 

  1641. 

  1642. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

  1643. void lglw_keyboard_callback_set(lglw_t _lglw, lglw_keyboard_fxn_t _cbk) {

  1644.    LGLW(_lglw);

  1645. 

  1646.    if(NULL != lglw)

  1647.    {

  1648.       lglw->keyboard.cbk = _cbk;

  1649.    }

  1650. }

  1651. 

  1652. 

  1653. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  1654. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  1655.    uint32_t r = 0u;

  1656.    LGLW(_lglw);

  1657. 

  1658.    if(NULL != lglw)

  1659.    {

  1660.       r = lglw->keyboard.kmod_state;

  1661.    }

  1662. 

  1663.    return r;

  1664. }

  1665. 

  1666. 

  1667. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

  1668. void lglw_touchkeyboard_show(lglw_t _lglw, lglw_bool_t _bEnable) {

  1669.    LGLW(_lglw);

  1670. 

  1671.    // (todo) implement me

  1672. 

  1673.    if(NULL != lglw)

  1674.    {

  1675.    }

  1676. }

  1677. 

  1678. 

  1679. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  1680. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  1681.    uint32_t r = 0u;

  1682.    LGLW(_lglw);

  1683. 

  1684.    if(NULL != lglw)

  1685.    {

  1686.       r = lglw->mouse.button_state;

  1687.    }

  1688. 

  1689.    return r;

  1690. }

  1691. 

  1692. 

  1693. // ---------------------------------------------------------------------------- lglw_mouse_grab

  1694. void lglw_mouse_grab(lglw_t _lglw, uint32_t _grabMode) {

  1695.    LGLW(_lglw);

  1696. 

  1697.    if(NULL != lglw)

  1698.    {

  1699.       if(0 != lglw->win.xwnd)

  1700.       {

  1701.          if(!lglw->mouse.touch.b_enable)

  1702.          {

  1703.             if(lglw->mouse.grab.mode != _grabMode)

  1704.             {

  1705.                lglw_mouse_ungrab(_lglw);

  1706.             }

  1707. 

  1708.             int result;

  1709. 

  1710.             switch(_grabMode)

  1711.             {

  1712.                default:

  1713.                case LGLW_MOUSE_GRAB_NONE:

  1714.                   break;

  1715. 

  1716.                case LGLW_MOUSE_GRAB_CAPTURE:

  1717.                   result = XGrabPointer(lglw->xdsp, lglw->win.xwnd,

  1718.                                         True/*owner_events*/,

  1719.                                         ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | PointerMotionHintMask | ButtonMotionMask | KeymapStateMask/*event_mask*/,

  1720.                                         GrabModeAsync/*pointer_mode*/,

  1721.                                         GrabModeAsync/*keyboard_mode*/,

  1722.                                         lglw->win.xwnd/*confine_to*/,

  1723.                                         None/*cursor*/,

  1724.                                         CurrentTime/*time*/);

  1725.                   if(GrabSuccess != result)

  1726.                   {

  1727.                      printf("vstgltest<lglw_linux>: Grab Result: %i\n", result);

  1728.                   }

  1729.                   else

  1730.                   {

  1731.                      lglw->mouse.grab.mode = _grabMode;

  1732.                   }

  1733.                   break;

  1734. 

  1735.                case LGLW_MOUSE_GRAB_WARP:

  1736.                   result = XGrabPointer(lglw->xdsp, lglw->win.xwnd,

  1737.                                         True/*owner_events*/,

  1738.                                         ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | PointerMotionHintMask | ButtonMotionMask | KeymapStateMask/*event_mask*/,

  1739.                                         GrabModeAsync/*pointer_mode*/,

  1740.                                         GrabModeAsync/*keyboard_mode*/,

  1741.                                         lglw->win.xwnd/*confine_to*/,

  1742.                                         None/*cursor*/,

  1743.                                         CurrentTime/*time*/);

  1744.                   if(GrabSuccess != result)

  1745.                   {

  1746.                      printf("vstgltest<lglw_linux>: Grab Result: %i\n", result);

  1747.                   }

  1748.                   else

  1749.                   {

  1750.                      lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

  1751.                      lglw->mouse.grab.p = lglw->mouse.p;

  1752.                      lglw->mouse.grab.last_p = lglw->mouse.p;

  1753.                      lglw->mouse.grab.mode = _grabMode;

  1754.                   }

  1755.                   break;

  1756.             }

  1757.          }

  1758.       }

  1759.    }

  1760. }

  1761. 

  1762. 

  1763. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  1764. void lglw_mouse_ungrab(lglw_t _lglw) {

  1765.    LGLW(_lglw);

  1766. 

  1767.    if(NULL != lglw)

  1768.    {

  1769.       if(0 != lglw->win.xwnd)

  1770.       {

  1771.          if(!lglw->mouse.touch.b_enable)

  1772.          {

  1773.             switch(lglw->mouse.grab.mode)

  1774.             {

  1775.                default:

  1776.                case LGLW_MOUSE_GRAB_NONE:

  1777.                   break;

  1778. 

  1779.                case LGLW_MOUSE_GRAB_CAPTURE:

  1780.                   XUngrabPointer(lglw->xdsp, CurrentTime);

  1781.                   lglw->mouse.grab.mode = LGLW_MOUSE_GRAB_NONE;

  1782.                   break;

  1783. 

  1784.                case LGLW_MOUSE_GRAB_WARP:

  1785.                   XUngrabPointer(lglw->xdsp, CurrentTime);

  1786.                   lglw->mouse.grab.mode = LGLW_MOUSE_GRAB_NONE;

  1787.                   lglw->mouse.grab.b_queue_warp = LGLW_TRUE;

  1788.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1789.                   break;

  1790.             }

  1791.          }

  1792.       }

  1793.    }

  1794. }

  1795. 

  1796. 

  1797. // ---------------------------------------------------------------------------- lglw_mouse_warp

  1798. void lglw_mouse_warp(lglw_t _lglw, int32_t _x, int32_t _y) {

  1799.    LGLW(_lglw);

  1800. 

  1801.    if(NULL != lglw)

  1802.    {

  1803.       if(0 != lglw->win.xwnd)

  1804.       {

  1805.          XWarpPointer(lglw->xdsp,

  1806.                       None/*src_w*/,

  1807.                       lglw->win.xwnd/*dest_w*/,

  1808.                       0/*src_x*/,

  1809.                       0/*src_y*/,

  1810.                       0/*src_width*/,

  1811.                       0/*src_height*/,

  1812.                       _x/*dest_x*/,

  1813.                       _y/*dest_y*/);

  1814.       }

  1815.    }

  1816. }

  1817. 

  1818. 

  1819. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1820. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

  1821.    if(lglw->mouse.grab.b_queue_warp)

  1822.    {

  1823.       lglw->mouse.grab.b_queue_warp = LGLW_FALSE;

  1824.       lglw_mouse_warp(lglw, lglw->mouse.grab.p.x, lglw->mouse.grab.p.y);

  1825.       lglw->mouse.grab.last_p = lglw->mouse.grab.p;

  1826.    }

  1827. }

  1828. 

  1829. 

  1830. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

  1831. void lglw_mouse_cursor_show (lglw_t _lglw, lglw_bool_t _bShow) {

  1832.    LGLW(_lglw);

  1833. 

  1834.    if(NULL != lglw)

  1835.    {

  1836.       if(LGLW_FALSE == _bShow)

  1837.       {

  1838.          Pixmap noPxm;

  1839.          Cursor noCursor;

  1840.          XColor black, dummy;

  1841.          static char pxmNoData[] = {0, 0, 0, 0, 0, 0, 0, 0};

  1842. 

  1843.          XAllocNamedColor(lglw->xdsp, lglw->cmap, "black", &black, &dummy);

  1844.          noPxm = XCreateBitmapFromData(lglw->xdsp, lglw->win.xwnd, pxmNoData, 8, 8);

  1845.          noCursor = XCreatePixmapCursor(lglw->xdsp, noPxm, noPxm, &black, &black, 0, 0);

  1846. 

  1847.          XDefineCursor(lglw->xdsp, lglw->win.xwnd, noCursor);

  1848.          XFreeCursor(lglw->xdsp, noCursor);

  1849.          if(noPxm != None)

  1850.          {

  1851.             XFreePixmap(lglw->xdsp, noPxm);

  1852.          }

  1853.       }

  1854.       else

  1855.       {

  1856.          XUndefineCursor(lglw->xdsp, lglw->win.xwnd);

  1857.       }

  1858.    }

  1859. }

  1860. 

  1861. 

  1862. // ---------------------------------------------------------------------------- lglw_timer_start

  1863. void lglw_timer_start(lglw_t _lglw, uint32_t _millisec) {

  1864.    LGLW(_lglw);

  1865. 

  1866.    if(NULL != lglw)

  1867.    {

  1868.       lglw_log("xxx lglw_linux:lglw_timer_start: interval=%u\n", _millisec);

  1869.       lglw->timer.interval_ms = _millisec;

  1870.       lglw->timer.b_running   = LGLW_TRUE;

  1871.    }

  1872. }

  1873. 

  1874. 

  1875. // ---------------------------------------------------------------------------- lglw_timer_stop

  1876. void lglw_timer_stop(lglw_t _lglw) {

  1877.    LGLW(_lglw);

  1878. 

  1879.    if(NULL != lglw)

  1880.    {

  1881.       lglw_log("xxx lglw_linux:lglw_timer_stop\n");

  1882.       lglw->timer.b_running = LGLW_FALSE;

  1883.    }

  1884. }

  1885. 

  1886. 

  1887. // ---------------------------------------------------------------------------- lglw_timer_callback_set

  1888. void lglw_timer_callback_set(lglw_t _lglw, lglw_timer_fxn_t _cbk) {

  1889.    LGLW(_lglw);

  1890. 

  1891.    if(NULL != lglw)

  1892.    {

  1893.       lglw->timer.cbk = _cbk;

  1894.    }

  1895. }

  1896. 

  1897. 

  1898. // ---------------------------------------------------------------------------- loc_process_timer()

  1899. static void loc_process_timer(lglw_int_t *lglw) {

  1900.    if(lglw->timer.b_running)

  1901.    {

  1902.       uint32_t ms = loc_millisec_delta(lglw);

  1903. 

  1904.       if( (ms - lglw->timer.last_ms) >= lglw->timer.interval_ms )

  1905.       {

  1906.          lglw->timer.last_ms = ms;

  1907. 

  1908.          if(NULL != lglw->timer.cbk)

  1909.          {

  1910.             lglw->timer.cbk(lglw);

  1911.          }

  1912.       }

  1913.    }

  1914. }

  1915. 

  1916. 

  1917. // ---------------------------------------------------------------------------- loc_enable_dropfiles

  1918. static void loc_enable_dropfiles(lglw_int_t *lglw, lglw_bool_t _bEnable) {

  1919. 

  1920.    // (todo) implement me

  1921. }

  1922. 

  1923. 

  1924. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

  1925. void lglw_dropfiles_callback_set(lglw_t _lglw, lglw_dropfiles_fxn_t _cbk) {

  1926.    LGLW(_lglw);

  1927. 

  1928.    if(NULL != _lglw)

  1929.    {

  1930.       lglw->dropfiles.cbk = _cbk;

  1931. 

  1932.       loc_enable_dropfiles(lglw, (NULL != _cbk));

  1933.    }

  1934. }

  1935. 

  1936. 

  1937. // ---------------------------------------------------------------------------- lglw_touchinput_set

  1938. void lglw_touchinput_set(lglw_t _lglw, lglw_bool_t _bEnable) {

  1939.    LGLW(_lglw);

  1940. 

  1941.    if(NULL != _lglw)

  1942.    {

  1943.       lglw->mouse.touch.b_enable = _bEnable;

  1944.       lglw->mouse.touch.b_update_queued = LGLW_TRUE;

  1945.    }

  1946. }

  1947. 

  1948. 

  1949. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1950. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1951.    lglw_bool_t r = LGLW_FALSE;

  1952.    LGLW(_lglw);

  1953. 

  1954.    if(NULL != _lglw)

  1955.    {

  1956.       r = lglw->mouse.touch.b_enable;

  1957.    }

  1958. 

  1959.    return r;

  1960. }

  1961. 

  1962. 

  1963. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

  1964. void lglw_clipboard_text_set(lglw_t _lglw, const uint32_t _numChars, const char *_text) {

  1965.    LGLW(_lglw);

  1966.    (void)_numChars;

  1967. 

  1968.    if(NULL != _text)

  1969.    {

  1970.       if(NULL != _lglw)

  1971.       {

  1972.          if(0 != lglw->win.xwnd)

  1973.          {

  1974.             uint32_t numChars = (0u == _numChars) ? ((uint32_t)strlen(_text)+1u) : _numChars;

  1975. 

  1976.             if(numChars > 0u)

  1977.             {

  1978.                lglw->clipboard.numChars = numChars;

  1979.                lglw->clipboard.data = malloc(numChars+1);

  1980. 

  1981.                uint32_t i;

  1982.                for(i = 0u; i < numChars; i++)

  1983.                {

  1984.                   lglw->clipboard.data[i] = _text[i];

  1985.                }

  1986.                lglw->clipboard.data[numChars - 1] = 0;

  1987. 

  1988.                printf("xxx lglw_clipboard_text_set(%i): %s\n", lglw->clipboard.numChars, lglw->clipboard.data);

  1989. 

  1990.                Atom clipboard = XInternAtom(lglw->xdsp, "CLIPBOARD", False);

  1991.                XSetSelectionOwner(lglw->xdsp, clipboard, lglw->win.xwnd, CurrentTime);

  1992.                XSync(lglw->xdsp, False);

  1993.             }

  1994.          }

  1995.       }

  1996.    }

  1997. }

  1998. 

  1999. 

  2000. // ---------------------------------------------------------------------------- loc_is_clipboard_event

  2001. static Bool loc_is_clipboard_event(Display *_display, XEvent *_xevent, XPointer _xarg) {

  2002.    return _xevent->type == SelectionNotify;

  2003. }

  2004. 

  2005. 

  2006. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

  2007. void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNumChars, char *_retText) {

  2008.    LGLW(_lglw);

  2009. 

  2010.    if(NULL != _retNumChars)

  2011.       *_retNumChars = 0u;

  2012. 

  2013.    if(NULL != _retText)

  2014.       *_retText = 0;

  2015. 

  2016.    if(_maxChars > 0u)

  2017.    {

  2018.       if(NULL != _lglw)

  2019.       {

  2020.          if(0 != lglw->win.xwnd)

  2021.          {

  2022.             Window owner;

  2023.             XEvent xev;

  2024.             XSelectionEvent *cbReq;

  2025.             Atom clipboard = XInternAtom(lglw->xdsp, "CLIPBOARD", False);

  2026.             Atom utf8 = XInternAtom(lglw->xdsp, "UTF8_STRING", False);

  2027.             Atom target = XInternAtom(lglw->xdsp, "_clipboard_result", False);

  2028. 

  2029.             owner = XGetSelectionOwner(lglw->xdsp, clipboard);

  2030.             if(owner == None)

  2031.             {

  2032.                printf("xxx lglw_clipboard_text_get: No Window can provide a clipboard result\n");

  2033.                return;

  2034.             }

  2035. 

  2036.             if(owner == lglw->win.xwnd)

  2037.             {

  2038.                printf("xxx lglw_clipboard_text_get: We are the owner of the clipboard, skip X interactions\n");

  2039. 

  2040.                uint32_t i = 0u;

  2041.                for(; i < _maxChars; i++)

  2042.                {

  2043.                   _retText[i] = lglw->clipboard.data[i];

  2044.                   if(0 == _retText[i])

  2045.                      break;

  2046.                }

  2047.                _retText[_maxChars - 1u] = 0;

  2048. 

  2049.                if(NULL != _retNumChars)

  2050.                   *_retNumChars = i;

  2051. 

  2052.                printf("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);

  2053.                return;

  2054.             }

  2055. 

  2056.             XConvertSelection(lglw->xdsp, clipboard, utf8, target, lglw->win.xwnd, CurrentTime);

  2057.             XIfEvent(lglw->xdsp, &xev, &loc_is_clipboard_event, None);

  2058. 

  2059.             cbReq = (XSelectionEvent*)&xev;

  2060.             if(None == cbReq->property)

  2061.             {

  2062.                printf("xxx lglw_clipboard_text_get: Clipboard was not converted to UTF-8 string\n");

  2063.                return;

  2064.             }

  2065. 

  2066.             Atom returnType;

  2067.             int returnFormat;

  2068.             unsigned long size, returnSize, bytesLeft;

  2069.             unsigned char *propertyValue = NULL;

  2070. 

  2071.             XGetWindowProperty(lglw->xdsp, lglw->win.xwnd, target,

  2072.                                0/*offset*/,

  2073.                                0/*length*/,

  2074.                                False/*delete*/,

  2075.                                AnyPropertyType/*req_type*/,

  2076.                                &returnType/*actual_type_return*/,

  2077.                                &returnFormat/*actual_format_return*/,

  2078.                                &returnSize/*nitems_return*/,

  2079.                                &size/*bytes_after_return*/,

  2080.                                &propertyValue/*prop_return*/);

  2081.             XFree(propertyValue);

  2082. 

  2083.             if(utf8 != returnType)

  2084.             {

  2085.                printf("xxx lglw_clipboard_text_get: Clipboard result is not a UTF-8 string\n");

  2086.                return;

  2087.             }

  2088. 

  2089.             if(8u != returnFormat)

  2090.             {

  2091.                printf("xxx lglw_clipboard_text_get: Clipboard format is not a char array\n");

  2092.                return;

  2093.             }

  2094. 

  2095.             if(_maxChars < size)

  2096.                size = _maxChars;

  2097.             size = 1 + ((size - 1) / 4);

  2098. 

  2099.             // TODO: Even with the largest current use-case, multiple calls aren't necessary. do it anyway just in case

  2100.             XGetWindowProperty(lglw->xdsp, lglw->win.xwnd, target,

  2101.                                0/*offset*/,

  2102.                                size/*length*/,

  2103.                                True/*delete*/,

  2104.                                AnyPropertyType/*req_type*/,

  2105.                                &returnType/*actual_type_return*/,

  2106.                                &returnFormat/*actual_format_return*/,

  2107.                                &returnSize/*nitems_return*/,

  2108.                                &bytesLeft/*bytes_after_return*/,

  2109.                                &propertyValue/*prop_return*/);

  2110. 

  2111.             if(returnSize == 0)

  2112.             {

  2113.                printf("xxx lglw_clipboard_text_get: No Clipboard result after final request\n");

  2114.                return;

  2115.             }

  2116. 

  2117.             uint32_t i = 0u;

  2118.             for(; i < _maxChars; i++)

  2119.             {

  2120.                _retText[i] = propertyValue[i];

  2121.                if(0 == _retText[i])

  2122.                   break;

  2123.             }

  2124.             _retText[_maxChars - 1u] = 0;

  2125. 

  2126.             if(NULL != _retNumChars)

  2127.                *_retNumChars = i;

  2128. 

  2129.             printf("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);

  2130.             XFree(propertyValue);

  2131.          }

  2132.       }

  2133.    }

  2134. }

  2135. 

  2136. // ---------------------------------------------------------------------------- lglw_events

  2137. void lglw_events(lglw_t _lglw) {

  2138.    LGLW(_lglw);

  2139. 

  2140.    if(NULL != lglw)

  2141.    {

  2142.       if(0 != lglw->win.xwnd)

  2143.       {

  2144. #if 0

  2145.          //int numEv = XEventsQueued(lglw->xdsp, QueuedAlready);

  2146.          int numEv = XEventsQueued(lglw->xdsp, QueuedAfterReading);

  2147.          // => numEv is always 0

  2148.          int evIdx = 0;

  2149.          printf("xxx lglw_events: numEv=%d\n", numEv);

  2150. 

  2151.          //for(; evIdx < numEv; evIdx++)

  2152.          for(;;)

  2153.          {

  2154.             XEvent xev;

  2155.             XNextEvent(lglw->xdsp, &xev);

  2156.             printf("xxx lglw_events: XNextEvent[%d]\n", evIdx++);

  2157.             loc_eventProc(&xev, lglw);

  2158.          }

  2159. #else

  2160.          // // int evIdx = 0;

  2161.          // // for(;;)

  2162.          // // {

  2163.          // //    XEvent xev;

  2164.          // //    // => blocks forever

  2165.          // //    XNextEvent(lglw->xdsp, &xev);

  2166.          // //    printf("xxx XNextEvent[%d]\n", evIdx++);

  2167.          // // }

  2168. 

  2169.          loc_process_timer(lglw);

  2170. #endif

  2171.          

  2172.       }

  2173.    }

  2174. }