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.
1182 Commits
4 Branches
677MB
Tree: 299be69ee5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '299be69ee5'
${ noResults }
Rack/dep/lglw/lglw_linux.c

2211 lines
72KB
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. //

  51. // Regular log entry (low frequency)

  52. //

  53. // #define Dlog_verbose if(1);else lglw_log

  54. #define Dlog if(0);else lglw_log

  55. 

  56. //

  57. // Verbose log entry

  58. //

  59. // #define Dlog_v if(1);else lglw_log

  60. #define Dlog_v if(0);else lglw_log

  61. 

  62. //

  63. // Very-verbose log entry

  64. //

  65. // #define Dlog_vv if(1);else lglw_log

  66. #define Dlog_vv if(0);else lglw_log

  67. 

  68. //

  69. // Very-very-verbose log entry

  70. //

  71. #define Dlog_vvv if(1);else lglw_log

  72. // #define Dlog_vvv if(0);else lglw_log

  73. 

  74. //

  75. // Print to stdout

  76. //

  77. //   Please use the Dlog* macros instead!

  78. //

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

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

  81. 

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

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

  84. 

  85. // ---------------------------------------------------------------------------- macros and defines

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

  87. 

  88. #define LGLW_DEFAULT_HIDDEN_W  (800)

  89. #define LGLW_DEFAULT_HIDDEN_H  (600)

  90. 

  91. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  92. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  93. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  94. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  95. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  96. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  97. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  98. 

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

  100. 

  101. 

  102. // ---------------------------------------------------------------------------- structs and typedefs

  103. typedef struct lglw_int_s {

  104.    void        *user_data;    // arbitrary user data

  105.    Display     *xdsp;

  106.    XVisualInfo *vi;

  107.    Colormap     cmap;

  108.    Window       parent_xwnd;  // created by host

  109. 

  110.    struct {

  111.       lglw_vec2i_t size;

  112.       Window       xwnd;

  113.    } hidden;

  114. 

  115.    struct {

  116.       lglw_vec2i_t size;

  117.       Window       xwnd;

  118.       lglw_bool_t  mapped;

  119.       int32_t      swap_interval;

  120.       lglw_bool_t  b_owner;

  121.    } win;

  122. 

  123.    GLXContext   ctx;

  124. 

  125.    struct {

  126.       GLXContext   ctx;

  127.       GLXDrawable  drw;

  128.    } prev;

  129. 

  130.    struct {

  131.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  132.       lglw_keyboard_fxn_t cbk;

  133.    } keyboard;

  134. 

  135.    struct {

  136.       lglw_vec2i_t     p;  // last seen mouse position

  137.       uint32_t         button_state;

  138.       lglw_mouse_fxn_t cbk;

  139.       struct {

  140.          uint32_t         mode;

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

  142.          lglw_bool_t      b_queue_warp;

  143.          lglw_vec2i_t     last_p;

  144.       } grab;

  145.       struct {

  146.          lglw_bool_t      b_enable;

  147.          lglw_bool_t      b_update_queued;

  148.          lglw_bool_t      b_syn_rmb;

  149.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  150.          uint32_t         hold_start_ms;

  151.          lglw_vec2i_t     hold_start_p;

  152.       } touch;

  153.    } mouse;

  154. 

  155.    struct {

  156.       uint32_t         state;

  157.       lglw_focus_fxn_t cbk;

  158.    } focus;

  159. 

  160.    struct {

  161.       lglw_bool_t      b_running;

  162.       lglw_timer_fxn_t cbk;

  163.       struct timeval   tv_start;

  164.       uint32_t         interval_ms;

  165.       uint32_t         last_ms;

  166.    } timer;

  167. 

  168.    struct {

  169.       uint32_t numChars;

  170.       char *data;

  171.    } clipboard;

  172. 

  173.    struct {

  174.       lglw_dropfiles_fxn_t cbk;

  175.    } dropfiles;

  176. 

  177.    struct {

  178.       lglw_redraw_fxn_t cbk;

  179.    } redraw;

  180. 

  181. } lglw_int_t;

  182. 

  183. 

  184. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  186. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  187. 

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

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

  190. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  191. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  192. 

  193. static void loc_handle_mouseleave (lglw_int_t *lglw);

  194. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  196. static void loc_handle_mousemotion (lglw_int_t *lglw);

  197. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  198. 

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

  200. 

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

  202. static void loc_XEventProc (void *_xevent);

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

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

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

  206. 

  207. static void loc_millisec_init (lglw_int_t *lglw);

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

  209. static void loc_process_timer (lglw_int_t *lglw);

  210. 

  211. 

  212. // ---------------------------------------------------------------------------- lglw_millisec_init

  213. static void loc_millisec_init (lglw_int_t *lglw) {

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

  215. }

  216. 

  217. // ---------------------------------------------------------------------------- lglw_millisec_delta

  218. static uint32_t loc_millisec_delta (lglw_int_t *lglw) {

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

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

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

  222. }

  223. 

  224. 

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

  226. // ---------------------------------------------------------------------------- lglw_log

  227. static FILE *logfile;

  228. 

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

  230.    fprintf(logfile, logData);

  231.    fflush(logfile);

  232.    printf(logData);

  233. }

  234. 

  235. 

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

  237. // ---------------------------------------------------------------------------- xerror_log

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

  239.    char error_text[1024];

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

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

  242.    return 0;

  243. }

  244. 

  245. 

  246. // ---------------------------------------------------------------------------- lglw_init

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

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

  249. 

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

  251. 

  252.    // TODO: remove/improve

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

  254.    XSetErrorHandler(xerror_handler);

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

  256.    

  257.    loc_millisec_init(lglw);

  258. 

  259.    if(NULL != lglw)

  260.    {

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

  262. 

  263.       Dlog("lglw:lglw_init: 1\n");

  264.       if(_w <= 16)

  265.          _w = LGLW_DEFAULT_HIDDEN_W;

  266. 

  267.       if(_h <= 16)

  268.          _h = LGLW_DEFAULT_HIDDEN_H;

  269. 

  270.       Dlog("lglw:lglw_init: 2\n");

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

  272.       {

  273.          free(lglw);

  274.          lglw = NULL;

  275.       }

  276.       Dlog("lglw:lglw_init: 3\n");

  277.    }

  278. 

  279.    Dlog("lglw:lglw_init: EXIT\n");

  280. 

  281.    return lglw;

  282. }

  283. 

  284. 

  285. // ---------------------------------------------------------------------------- lglw_exit

  286. void lglw_exit(lglw_t _lglw) {

  287.    LGLW(_lglw);

  288. 

  289.    if(NULL != lglw)

  290.    {

  291.       Dlog("lglw:lglw_exit: 1\n");

  292. 

  293.       loc_destroy_hidden_window(lglw);

  294. 

  295.       Dlog("lglw:lglw_exit: 2\n");

  296. 

  297.       fclose(logfile);

  298.       free(lglw);

  299.    }

  300. }

  301. 

  302. 

  303. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  305.    LGLW(_lglw);

  306. 

  307.    if(NULL != lglw)

  308.    {

  309.       Dlog_vvv("lglw:lglw_userdata_set: ptr=%p\n", _userData);

  310.       lglw->user_data = _userData;

  311.    }

  312. }

  313. 

  314. // ---------------------------------------------------------------------------- lglw_userdata_get

  315. void *lglw_userdata_get(lglw_t _lglw) {

  316.    LGLW(_lglw);

  317. 

  318.    if(NULL != lglw)

  319.    {

  320.       Dlog_vvv("lglw:lglw_userdata_get: return ptr=%p\n", lglw->user_data);

  321.       return lglw->user_data;

  322.    }

  323. 

  324.    return NULL;

  325. }

  326. 

  327. 

  328. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  330. 

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

  332. 

  333.    Dlog_v("lglw:loc_create_hidden_window: 1\n");

  334.    XSetWindowAttributes swa;

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

  336.    int screen;

  337. 

  338.    Dlog_v("lglw:loc_create_hidden_window: 2\n");

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

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

  341. 

  342.    Dlog_v("lglw:loc_create_hidden_window: 3\n");

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

  344. 

  345.    Dlog_v("lglw:loc_create_hidden_window: 4\n");

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

  347.    {

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

  349.       return LGLW_FALSE;

  350.    }

  351. 

  352.    Dlog_v("lglw:loc_create_hidden_window: 5\n");

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

  354. 

  355.    Dlog_v("lglw:loc_create_hidden_window: 6\n");

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

  357.    {

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

  359.       return LGLW_FALSE;

  360.    }

  361. 

  362.    Dlog_v("lglw:loc_create_hidden_window: 7\n");

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

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

  365. 

  366.    Dlog_v("lglw:loc_create_hidden_window: 8\n");

  367.    swa.border_pixel = 0;

  368.    swa.colormap = lglw->cmap;

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

  370.                                      0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  372. 

  373.    Dlog_v("lglw:loc_create_hidden_window: 9\n");

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

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

  376. 

  377.    Dlog_v("lglw:loc_create_hidden_window: EXIT\n");

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

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

  380. 

  381.    return LGLW_TRUE;

  382. }

  383. 

  384. 

  385. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  386. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

  387.    Dlog_v("lglw:loc_destroy_hidden_window: 1\n");

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

  389.    {

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

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

  392.    }

  393.    Dlog_v("lglw:loc_destroy_hidden_window: 2\n");

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

  395.    Dlog_v("lglw:loc_destroy_hidden_window: 3\n");

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

  397.    Dlog_v("lglw:loc_destroy_hidden_window: 4\n");

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

  399. 

  400.    Dlog_v("lglw:loc_destroy_hidden_window: 5\n");

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

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

  403. }

  404. 

  405. 

  406. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  413. 

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

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

  416. 

  417.    Dlog_vvv("lglw:loc_eventProc: type=%d serial=%lu send_event=%d lglw=%p\n", xev->xany.type, xev->xany.serial, xev->xany.send_event, lglw);

  418. 

  419.    loc_process_timer(lglw);

  420. 

  421.    if(NULL != lglw)

  422.    {

  423.       lglw_bool_t eventHandled = LGLW_FALSE;

  424. 

  425.       switch(xev->type)

  426.       {

  427.          default:

  428.             Dlog("lglw:loc_eventProc: unhandled X11 event type=%d\n", xev->type);

  429.             eventHandled = LGLW_FALSE;

  430.             break;

  431. 

  432.          case Expose:

  433.             Dlog_v("lglw:loc_eventProc: xev Expose\n");

  434.             loc_handle_queued_mouse_warp(lglw);

  435.             eventHandled = LGLW_FALSE;

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

  437.             {

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

  439.                eventHandled = LGLW_TRUE;

  440.             }

  441.             break;

  442. 

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

  444. 

  445.          case FocusIn:

  446.             Dlog_v("lglw:loc_eventProc: xev FocusIn\n");

  447.             eventHandled = LGLW_FALSE;

  448.             break;

  449. 

  450.          case FocusOut:

  451.             Dlog_v("lglw:loc_eventProc: xev FocusOut\n");

  452.             eventHandled = LGLW_FALSE;

  453.             break;

  454. 

  455.          case EnterNotify:

  456.             // Dlog_v("lglw:loc_eventProc: xev XEnterWindowEvent\n");

  457.             ; // empty statement

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

  459.             Dlog_v("lglw:loc_eventProc: xev EnterNotify: mode:%i, detail:%i, state:%d\n", wenter->mode, wenter->detail, wenter->state);

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

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

  462.             loc_handle_mousemotion(lglw);

  463. 

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

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

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

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

  468.             {

  469.                loc_handle_mouseenter(lglw);

  470.             }

  471.             eventHandled = LGLW_TRUE;

  472. 

  473.             break;

  474. 

  475.          case LeaveNotify:

  476.             // Dlog_v("lglw:loc_eventProc: xev XLeaveWindowEvent\n");

  477.             ; // empty statement

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

  479.             Dlog_v("lglw:loc_eventProc: xev LeaveNotify: mode:%i, detail:%i, state:%d\n", wexit->mode, wexit->detail, wexit->state);

  480. 

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

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

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

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

  485.             {

  486.                loc_handle_mouseleave(lglw);

  487.             }

  488.             eventHandled = LGLW_TRUE;

  489. 

  490.             break;

  491. 

  492.          case MotionNotify:

  493.             Dlog_v("lglw:loc_eventProc: xev MotionNotify\n");

  494.             ; // empty statement

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

  496. 

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

  498.             {

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

  500. 

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

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

  503. 

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

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

  506.             }

  507.             else

  508.             {

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

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

  511.             }

  512. 

  513.             loc_handle_mousemotion(lglw);

  514.             eventHandled = LGLW_TRUE;

  515. 

  516.             break;

  517. 

  518.          case KeyPress:

  519.             Dlog("lglw:loc_eventProc: xev KeyPress\n");

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

  521. 

  522.             eventHandled = LGLW_FALSE;

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

  524.             switch(xkp)

  525.             {

  526.                default:

  527.                   Dlog("lglw:loc_eventProc: xev KeyPress: %x or %lu\n", keyPress->keycode, xkp);

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

  529.                   {

  530.                      KeySym xkpl;

  531.                      KeySym xkpu;

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

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

  534.                   }

  535.                   else

  536.                   {

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

  538.                   }

  539.                   break;

  540. 

  541.                case NoSymbol:

  542.                   Dlog("lglw:loc_eventProc: xev UNKNOWN KeyPress: %x\n", keyPress->keycode);

  543.                   break;

  544. 

  545.                case XK_Left:

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

  547.                   break;

  548. 

  549.                case XK_Right:

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

  551.                   break;

  552. 

  553.                case XK_Up:

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

  555.                   break;

  556. 

  557.                case XK_Down:

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

  559.                   break;

  560. 

  561.                case XK_Insert:

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

  563.                   break;

  564. 

  565.                case XK_Delete:

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

  567.                   break;

  568. 

  569.                case XK_Home:

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

  571.                   break;

  572. 

  573.                case XK_End:

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

  575.                   break;

  576. 

  577.                case XK_Prior:

  578.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_PAGEUP);

  579.                   break;

  580. 

  581.                case XK_Next:

  582.                   eventHandled = loc_handle_key(lglw, LGLW_TRUE/*bPressed*/, LGLW_VKEY_PAGEDOWN);

  583.                   break;

  584. 

  585.                case XK_F1:

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

  587.                   break;

  588. 

  589.                case XK_F2:

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

  591.                   break;

  592. 

  593.                case XK_F3:

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

  595.                   break;

  596. 

  597.                case XK_F4:

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

  599.                   break;

  600. 

  601.                case XK_F5:

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

  603.                   break;

  604. 

  605.                case XK_F6:

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

  607.                   break;

  608. 

  609.                case XK_F7:

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

  611.                   break;

  612. 

  613.                case XK_F8:

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

  615.                   break;

  616. 

  617.                case XK_F9:

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

  619.                   break;

  620. 

  621.                case XK_F10:

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

  623.                   break;

  624. 

  625.                case XK_F11:

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

  627.                   break;

  628. 

  629.                case XK_F12:

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

  631.                   break;

  632. 

  633.                case XK_BackSpace:

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

  635.                   break;

  636. 

  637.                case XK_Tab:

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

  639.                   break;

  640. 

  641.                case XK_Return:

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

  643.                   break;

  644. 

  645.                case XK_Escape:

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

  647.                   break;

  648. 

  649.                case XK_Shift_L:

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

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

  652.                   eventHandled = LGLW_FALSE;

  653.                   break;

  654. 

  655.                case XK_Shift_R:

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

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

  658.                   eventHandled = LGLW_FALSE;

  659.                   break;

  660. 

  661.                case XK_Control_L:

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

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

  664.                   eventHandled = LGLW_FALSE;

  665.                   break;

  666. 

  667.                case XK_Control_R:

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

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

  670.                   eventHandled = LGLW_FALSE;

  671.                   break;

  672.             }

  673. 

  674.             break;

  675. 

  676.          case KeyRelease:

  677.             Dlog("lglw:loc_eventProc: xev KeyRelease\n");

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

  679. 

  680.             eventHandled = LGLW_FALSE;

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

  682.             switch(xkr)

  683.             {

  684.                default:

  685.                   Dlog("lglw:loc_eventProc: xev KeyRelease: %x or %lu\n", keyRelease->keycode, xkr);

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

  687.                   {

  688.                      KeySym xkrl;

  689.                      KeySym xkru;

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

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

  692.                   }

  693.                   else

  694.                   {

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

  696.                   }

  697.                   break;

  698. 

  699.                case NoSymbol:

  700.                   Dlog("lglw:loc_eventProc: xev UNKNOWN KeyRelease: %x\n", keyRelease->keycode);

  701.                   break;

  702. 

  703.                case XK_Left:

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

  705.                   break;

  706. 

  707.                case XK_Right:

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

  709.                   break;

  710. 

  711.                case XK_Up:

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

  713.                   break;

  714. 

  715.                case XK_Down:

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

  717.                   break;

  718. 

  719.                case XK_Insert:

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

  721.                   break;

  722. 

  723.                case XK_Delete:

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

  725.                   break;

  726. 

  727.                case XK_Home:

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

  729.                   break;

  730. 

  731.                case XK_End:

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

  733.                   break;

  734. 

  735.                case XK_Prior:

  736.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_PAGEUP);

  737.                   break;

  738. 

  739.                case XK_Next:

  740.                   eventHandled = loc_handle_key(lglw, LGLW_FALSE/*bPressed*/, LGLW_VKEY_PAGEDOWN);

  741.                   break;

  742. 

  743.                case XK_F1:

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

  745.                   break;

  746. 

  747.                case XK_F2:

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

  749.                   break;

  750. 

  751.                case XK_F3:

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

  753.                   break;

  754. 

  755.                case XK_F4:

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

  757.                   break;

  758. 

  759.                case XK_F5:

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

  761.                   break;

  762. 

  763.                case XK_F6:

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

  765.                   break;

  766. 

  767.                case XK_F7:

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

  769.                   break;

  770. 

  771.                case XK_F8:

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

  773.                   break;

  774. 

  775.                case XK_F9:

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

  777.                   break;

  778. 

  779.                case XK_F10:

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

  781.                   break;

  782. 

  783.                case XK_F11:

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

  785.                   break;

  786. 

  787.                case XK_F12:

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

  789.                   break;

  790. 

  791.                case XK_BackSpace:

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

  793.                   break;

  794. 

  795.                case XK_Tab:

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

  797.                   break;

  798. 

  799.                case XK_Return:

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

  801.                   break;

  802. 

  803.                case XK_Escape:

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

  805.                   break;

  806. 

  807.                case XK_Shift_L:

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

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

  810.                   eventHandled = LGLW_FALSE;

  811.                   break;

  812. 

  813.                case XK_Shift_R:

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

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

  816.                   eventHandled = LGLW_FALSE;

  817.                   break;

  818. 

  819.                case XK_Control_L:

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

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

  822.                   eventHandled = LGLW_FALSE;

  823.                   break;

  824. 

  825.                case XK_Control_R:

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

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

  828.                   eventHandled = LGLW_FALSE;

  829.                   break;

  830.             }

  831. 

  832.             break;

  833. 

  834.          case ButtonPress:

  835.             Dlog("lglw:loc_eventProc: xev ButtonPress\n");

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

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

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

  839. 

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

  841.             {

  842.                loc_handle_mouseenter(lglw);

  843.             }

  844. 

  845.             switch(btnPress->button)

  846.             {

  847.                default:

  848.                   Dlog("lglw:loc_eventProc: xev ButtonPress unhandled button: %i\n", btnPress->button);

  849.                   eventHandled = LGLW_FALSE;

  850.                   break;

  851.                case Button1:

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

  853.                   eventHandled = LGLW_TRUE;

  854.                   break;

  855.                case Button2:

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

  857.                   eventHandled = LGLW_TRUE;

  858.                   break;

  859.                case Button3:

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

  861.                   eventHandled = LGLW_TRUE;

  862.                   break;

  863.                case Button4:

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

  865.                   eventHandled = LGLW_TRUE;

  866.                   break;

  867.                case Button5:

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

  869.                   eventHandled = LGLW_TRUE;

  870.                   break;

  871.             }

  872.             break;

  873. 

  874.          case ButtonRelease:

  875.             Dlog("lglw:loc_eventProc: xev ButtonRelease\n");

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

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

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

  879.             switch(btnRelease->button)

  880.             {

  881.                default:

  882.                   Dlog("lglw:loc_eventProc: xev ButtonRelease unhandled button: %i\n", btnRelease->button);

  883.                   eventHandled = LGLW_FALSE;

  884.                   break;

  885.                case Button1:

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

  887.                   eventHandled = LGLW_TRUE;

  888.                   break;

  889.                case Button2:

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

  891.                   eventHandled = LGLW_TRUE;

  892.                   break;

  893.                case Button3:

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

  895.                   eventHandled = LGLW_TRUE;

  896.                   break;

  897.                case Button4:

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

  899.                   eventHandled = LGLW_TRUE;

  900.                   break;

  901.                case Button5:

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

  903.                   eventHandled = LGLW_TRUE;

  904.                   break;

  905.             }

  906.             break;

  907. 

  908.          case SelectionClear:

  909.             Dlog("lglw:loc_eventProc: xev SelectionClear\n");

  910.             lglw->clipboard.numChars = 0;

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

  912.             eventHandled = LGLW_TRUE;

  913.             break;

  914. 

  915.          case SelectionRequest:

  916.             Dlog("lglw:loc_eventProc: xev SelectionRequest\n");

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

  918.             XSelectionEvent cbRes;

  919. 

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

  921. 

  922.             cbRes.type = SelectionNotify;

  923.             cbRes.requestor = cbReq->requestor;

  924.             cbRes.selection = cbReq->selection;

  925.             cbRes.target = cbReq->target;

  926.             cbRes.time = cbReq->time;

  927. 

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

  929.             {

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

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

  932. 

  933.                cbRes.property = cbReq->property;

  934.             }

  935.             else

  936.             {

  937.                cbRes.property = None;

  938.             }

  939. 

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

  941.             eventHandled = LGLW_TRUE;

  942. 

  943.             break;

  944.       }

  945. 

  946. #if 0

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

  948.       if(LGLW_FALSE == eventHandled)

  949.       {

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

  951.          {

  952.             Dlog("lglw:loc_eventProc: no parent window to send events to");

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

  954.          }

  955.          else

  956.          {

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

  958.          }

  959.       }

  960. #else

  961.       (void)eventHandled;

  962. #endif

  963.    }

  964. }

  965. 

  966. static void loc_XEventProc(void *_xevent) {

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

  968. 

  969.    Dlog_vvv("lglw:loc_XEventProc: ENTER\n");

  970.    // Dlog_vvv("lglw: XEventProc, xev=%p\n", xev);

  971. 

  972.    if(NULL != xev)

  973.    {

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

  975.       Dlog_vvv("lglw:loc_XEventProc: xev=%p lglw=%p\n", xev, lglw);

  976. 

  977.       loc_eventProc(xev, lglw);

  978.    }

  979. 

  980.    Dlog_vvv("lglw:loc_XEventProc: LEAVE\n");

  981. }

  982. 

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

  984.    size_t data = (size_t)_value;

  985.    long temp[2];

  986. 

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

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

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

  990. 

  991.    Dlog_v("lglw:loc_setProperty: name=\"%s\" value=%p temp[0]=%08x temp[1]=%08x\n", _name, _value, (uint32_t)temp[0], (uint32_t)temp[1]);

  992. 

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

  994. 

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

  996.    XChangeProperty(_display, _window,

  997.                    atom/*property*/,

  998.                    atom/*type*/,

  999.                    32/*format*/,

  1000.                    PropModeReplace/*mode*/,

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

  1002.                    2/*nelements*/

  1003.                    );

  1004. }

  1005. 

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

  1007.    int userSize;

  1008.    unsigned long bytes;

  1009.    unsigned long userCount;

  1010.    unsigned char *data;

  1011.    Atom userType;

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

  1013. 

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

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

  1016.    XGetWindowProperty(_display,

  1017.                       _window,

  1018.                       atom,

  1019.                       0/*offset*/,

  1020.                       1/*length*/,

  1021.                       False/*delete*/,

  1022.                       AnyPropertyType,

  1023.                       &userType/*actual_type_return*/,

  1024.                       &userSize/*actual_format_return*/,

  1025.                       &userCount/*nitems_return*/,

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

  1027.                       &data);

  1028. 

  1029.    union {

  1030.       uint32_t ui[2];

  1031.       void *any;

  1032.    } uptr;

  1033.    uptr.any = 0;

  1034. 

  1035.    Dlog_vvv("lglw:loc_getProperty: LOWER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);

  1036. 

  1037.    if(NULL != data)

  1038.    {

  1039.       if(userCount >= 1)

  1040.       {

  1041.          // lower 32-bit

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

  1043.          uptr.ui[1] = 0;

  1044. 

  1045.          Dlog_vvv("lglw:loc_getProperty:    lower=0x%08x\n", uptr.ui[0]);

  1046. 

  1047.          XFree(data);

  1048. 

  1049.          XGetWindowProperty(_display,

  1050.                             _window,

  1051.                             atom,

  1052.                             1/*offset*/,

  1053.                             1/*length*/,

  1054.                             False/*delete*/,

  1055.                             AnyPropertyType,

  1056.                             &userType/*actual_type_return*/,

  1057.                             &userSize/*actual_format_return*/,

  1058.                             &userCount/*nitems_return*/,

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

  1060.                             &data);

  1061. 

  1062.          Dlog_vvv("lglw:loc_getProperty: UPPER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);

  1063.          if(NULL != data)

  1064.          {

  1065.             // upper 32-bit

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

  1067.             Dlog_vvv("lglw:loc_getProperty:    upper=0x%08x\n", uptr.ui[1]);

  1068.             XFree(data);

  1069.          }

  1070.       }

  1071.    }

  1072. 

  1073.    Dlog_vvv("lglw:loc_getProperty: return value=%p\n", uptr.any);

  1074. 

  1075.    return uptr.any;

  1076. }

  1077. 

  1078. 

  1079. #ifdef ARCH_X64

  1080. #if 0

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

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

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

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

  1085.    size_t data = (size_t)loc_eventProc;

  1086.    long temp[2];

  1087. 

  1088.    Dlog("lglw: setEventProc (2*32bit). window=%lu loc_eventProc=%p\n", window, &loc_eventProc);

  1089. 

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

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

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

  1093. 

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

  1095.    XChangeProperty(display, window,

  1096.                    atom/*property*/,

  1097.                    atom/*type*/,

  1098.                    32/*format*/,

  1099.                    PropModeReplace/*mode*/,

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

  1101.                    2/*nelements*/

  1102.                    );

  1103. }

  1104. #else

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

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

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

  1108.    //

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

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

  1111.    //

  1112. 

  1113.    // based on mach_override

  1114.    static const unsigned char kJumpInstructions[] = {

  1115.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  1116.          0x00, 0x00, 0x00, 0x00,

  1117.          0x00, 0x00, 0x00, 0x00

  1118.    };

  1119.    static const int kJumpAddress = 6;

  1120. 

  1121.    static char *ptr = 0;

  1122.    if (!ptr) {

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

  1124.                          getpagesize()/*PAGE_SIZE*/,

  1125.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  1126.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  1127.                          0, 0);

  1128.       if (ptr == MAP_FAILED) {

  1129.          perror("mmap");

  1130.          ptr = 0;

  1131.          return;

  1132.       } else {

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

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

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

  1136.          Dlog("lglw: 64bit trampoline installed\n");

  1137.       }

  1138.    }

  1139. 

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

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

  1142.    XChangeProperty(display, window,

  1143.                    atom/*property*/,

  1144.                    atom/*type*/,

  1145.                    32/*format*/,

  1146.                    PropModeReplace/*mode*/,

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

  1148.                    2/*nelements*/

  1149.                    );

  1150. }

  1151. #endif

  1152. #else

  1153. // Pulled from the eXT2 example

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

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

  1156. 

  1157.    // (note) 32-bit only

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

  1159.    XChangeProperty(display, window,

  1160.                    atom/*property*/,

  1161.                    atom/*type*/,

  1162.                    32/*format*/,

  1163.                    PropModeReplace/*mode*/,

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

  1165.                    1/*nelements*/

  1166.                    );

  1167. }

  1168. #endif // ARCH_X64

  1169. 

  1170. 

  1171. // ---------------------------------------------------------------------------- lglw_window_open

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

  1173.    lglw_bool_t r = LGLW_FALSE;

  1174.    LGLW(_lglw);

  1175. 

  1176.    if(NULL != lglw)

  1177.    {

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

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

  1180. 

  1181.       Dlog_v("lglw:lglw_window_open: 2 lglw=%p\n", lglw);

  1182.       if(_w <= 16)

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

  1184. 

  1185.       Dlog_v("lglw:lglw_window_open: 3\n");

  1186.       if(_h <= 16)

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

  1188. 

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

  1190. 

  1191.       Dlog_v("lglw:lglw_window_open: 4\n");

  1192.       XSetWindowAttributes swa;

  1193.       // // XEvent event;

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

  1195. 

  1196. #if 1

  1197.       Dlog_v("lglw:lglw_window_open: 5\n");

  1198.       swa.border_pixel = 0;

  1199.       swa.colormap = lglw->cmap;

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

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

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

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

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

  1205.                                      0/*x*/,

  1206.                                      0/*y*/,

  1207.                                      _w/*width*/,

  1208.                                      _h/*height*/,

  1209.                                      0/*border_width*/,

  1210.                                      CopyFromParent/*depth*/,

  1211.                                      InputOutput/*class*/,

  1212.                                      lglw->vi->visual,

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

  1214.                                      &swa/*attributes*/

  1215.                                      );

  1216. 

  1217.       Dlog_v("lglw:lglw_window_open: 6\n");

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

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

  1220.                              "LGLW"/*window_name*/,

  1221.                              "LGLW"/*icon_name*/,

  1222.                              None/*icon_pixmap*/,

  1223.                              NULL/*argv*/,

  1224.                              0/*argc*/,

  1225.                              NULL/*XSizeHints*/

  1226.                              );

  1227. 

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

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

  1230.       Dlog_v("lglw:lglw_window_open: 7\n");

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

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

  1233. 

  1234.       if(0 != _parentHWNDOrNull)

  1235.       {

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

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

  1238.       }

  1239. 

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

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

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

  1243. #if 1

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

  1245.       if (0 != _parentHWNDOrNull)

  1246.       {

  1247.          Dlog_v("lglw:lglw_window_open: 8\n");

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

  1249.       }

  1250. #endif

  1251.       lglw->win.b_owner = LGLW_TRUE;

  1252. #else

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

  1254.       lglw->win.b_owner = LGLW_FALSE;

  1255. #endif

  1256. 

  1257.       Dlog_v("lglw:lglw_window_open: 9\n");

  1258.       if(lglw->win.b_owner)

  1259.       {

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

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

  1262.       }

  1263. 

  1264. #if 0

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

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

  1267.                    );

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

  1269.                     False/*owner_events*/,

  1270.                     GrabModeAsync/*pointer_mode*/,

  1271.                     GrabModeAsync/*keyboard_mode*/,

  1272.                     CurrentTime/*time*/

  1273.                     );

  1274. #endif

  1275. 

  1276. #if 0

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

  1278.                      PointerRoot/*focus*/,

  1279.                      RevertToPointerRoot/*revert_to*/,

  1280.                      CurrentTime

  1281.                      );

  1282. #endif

  1283. 

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

  1285.       lglw->win.mapped = LGLW_TRUE;

  1286. 

  1287.       Dlog_v("lglw:lglw_window_open: 10\n");

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

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

  1290. 

  1291.       Dlog_v("lglw:lglw_window_open: 11\n");

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

  1293. 

  1294.       Dlog_v("lglw:lglw_window_open: EXIT\n");

  1295. 

  1296.       r = LGLW_TRUE;

  1297.    }

  1298.    return r;

  1299. }

  1300. 

  1301. 

  1302. // ---------------------------------------------------------------------------- lglw_window_resize

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

  1304.    lglw_bool_t r = LGLW_FALSE;

  1305.    LGLW(_lglw);

  1306. 

  1307.    if(NULL != lglw)

  1308.    {

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

  1310.       {

  1311.          Dlog_v("lglw:lglw_window_resize: 1\n");

  1312.          r = LGLW_TRUE;

  1313. 

  1314.          Dlog_v("lglw:lglw_window_resize: 2\n");

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

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

  1317. 

  1318.          Dlog_v("lglw:lglw_window_resize: 3\n");

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

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

  1321. 

  1322.          Dlog_v("lglw:lglw_window_resize: 4\n");

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

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

  1325. 

  1326.          Dlog_v("lglw:lglw_window_resize: 5\n");

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

  1328.          unsigned int num_children;

  1329. 

  1330.          Dlog_v("lglw:lglw_window_resize: 6\n");

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

  1332.             return r;

  1333. 

  1334.          Dlog_v("lglw:lglw_window_resize: 7\n");

  1335.          if(children)

  1336.             XFree((char *)children);

  1337. 

  1338.          Dlog_v("lglw:lglw_window_resize: 8\n");

  1339.          // Resize parent window (if any)

  1340.          if(0 != parent)

  1341.          {

  1342.             Dlog_v("lglw:lglw_window_resize: 8.1\n");

  1343.             int x, y;

  1344.             unsigned int width, height;

  1345.             unsigned int border_width;

  1346.             unsigned int depth;

  1347. 

  1348.             Dlog_v("lglw:lglw_window_resize: 8.2\n");

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

  1350.                return r;

  1351. 

  1352.             Dlog_v("lglw:lglw_window_resize: 8.3\n");

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

  1354.          }

  1355.          Dlog_v("lglw:lglw_window_resize: EXIT\n");

  1356.       }

  1357.    }

  1358. 

  1359.    return r;

  1360. }

  1361. 

  1362. 

  1363. // ---------------------------------------------------------------------------- lglw_window_close

  1364. void lglw_window_close (lglw_t _lglw) {

  1365.    LGLW(_lglw);

  1366. 

  1367.    if(NULL != lglw)

  1368.    {

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

  1370.       {

  1371.          Dlog_v("lglw:lglw_window_close: 1\n");

  1372.          lglw_timer_stop(_lglw);

  1373. 

  1374.          Dlog_v("lglw:lglw_window_close: 2\n");

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

  1376. 

  1377.          Dlog_v("lglw:lglw_window_close: 3\n");

  1378.          if(lglw->win.b_owner)

  1379.          {

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

  1381.             lglw->win.b_owner = LGLW_FALSE;

  1382.          }

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

  1384.          lglw->win.xwnd = 0;

  1385.          lglw->win.mapped = LGLW_FALSE;

  1386.       }

  1387.    }

  1388.    Dlog_v("lglw:lglw_window_close: EXIT\n");

  1389. }

  1390. 

  1391. 

  1392. // ---------------------------------------------------------------------------- lglw_window_show

  1393. void lglw_window_show(lglw_t _lglw) {

  1394.    LGLW(_lglw);

  1395. 

  1396.    if(NULL != lglw)

  1397.    {

  1398.       Dlog_v("lglw:lglw_window_show: 1\n");

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

  1400. 

  1401.       lglw->win.mapped = LGLW_TRUE;

  1402.    }

  1403.    Dlog_v("lglw:lglw_window_show: EXIT\n");

  1404. }

  1405. 

  1406. 

  1407. // ---------------------------------------------------------------------------- lglw_window_hide

  1408. void lglw_window_hide(lglw_t _lglw) {

  1409.    LGLW(_lglw);

  1410. 

  1411.    if(NULL != lglw)

  1412.    {

  1413.       Dlog_v("lglw:lglw_window_hide: 1\n");

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

  1415. 

  1416.       lglw->win.mapped = LGLW_FALSE;

  1417.    }

  1418.    Dlog_v("lglw:lglw_window_hide: EXIT\n");

  1419. }

  1420. 

  1421. 

  1422. // ---------------------------------------------------------------------------- lglw_window_is_visible

  1423. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  1424.    lglw_bool_t r = LGLW_FALSE;

  1425.    LGLW(_lglw);

  1426. 

  1427.    Dlog_vvv("lglw:lglw_window_is_visible: 1\n");

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

  1429.    {

  1430.       Dlog_vvv("lglw:lglw_window_is_visible: 2\n");

  1431.       r = lglw->win.mapped;

  1432.    }

  1433. 

  1434.    Dlog_vvv("lglw:lglw_window_is_visible: EXIT\n");

  1435.    return r;

  1436. }

  1437. 

  1438. 

  1439. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  1441.    LGLW(_lglw);

  1442. 

  1443.    Dlog_vvv("lglw:lglw_window_size_get: 1\n");

  1444.    if(NULL != lglw)

  1445.    {

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

  1447.       {

  1448.          if(NULL != _retX)

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

  1450. 

  1451.          if(NULL != _retY)

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

  1453.       }

  1454.    }

  1455.    Dlog_vvv("lglw:lglw_window_size_get: EXIT\n");

  1456. }

  1457. 

  1458. 

  1459. // ---------------------------------------------------------------------------- lglw_redraw

  1460. void lglw_redraw(lglw_t _lglw) {

  1461.    LGLW(_lglw);

  1462. 

  1463.    // (todo) implement me

  1464. 

  1465.    if(NULL != lglw)

  1466.    {

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

  1468.       {

  1469.          // TODO Event Loop

  1470.          Dlog_vvv("lglw:lglw_redraw: 1\n");

  1471.          XEvent xev;

  1472.          xev.xany.type       = Expose;

  1473.          xev.xany.serial     = 0;

  1474.          xev.xany.send_event = True;

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

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

  1477.          xev.xexpose.x      = 0;

  1478.          xev.xexpose.y      = 0;

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

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

  1481.          xev.xexpose.count  = 0;

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

  1483.                     True/*propagate*/,

  1484.                     ExposureMask/*event_mask*/,

  1485.                     &xev

  1486.                     );

  1487.          XFlush(lglw->xdsp);

  1488.       }

  1489.    }

  1490. }

  1491. 

  1492. 

  1493. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  1495.    LGLW(_lglw);

  1496. 

  1497.    if(NULL != lglw)

  1498.    {

  1499.       lglw->redraw.cbk = _cbk;

  1500.    }

  1501. }

  1502. 

  1503. 

  1504. // ---------------------------------------------------------------------------- lglw_glcontext_push

  1505. void lglw_glcontext_push(lglw_t _lglw) {

  1506.    LGLW(_lglw);

  1507. 

  1508.    if(NULL != lglw)

  1509.    {

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

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

  1512. 

  1513.       Dlog_vvv("lglw:lglw_glcontext_push: win.xwnd=%p hidden.xwnd=%p ctx=%p\n",

  1514.                lglw->win.xwnd, lglw->hidden.xwnd, lglw->ctx);

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

  1516.       {

  1517.          Dlog("[---] 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());

  1518.       }

  1519.    }

  1520. }

  1521. 

  1522. 

  1523. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  1524. void lglw_glcontext_pop(lglw_t _lglw) {

  1525.    LGLW(_lglw);

  1526. 

  1527.    if(NULL != lglw)

  1528.    {

  1529.       Dlog_vvv("lglw:lglw_glcontext_pop: prev.drw=%p prev.ctx=%p\n",

  1530.                lglw->prev.drw, lglw->prev.ctx);

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

  1532.       {

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

  1534.       }

  1535.    }

  1536. }

  1537. 

  1538. 

  1539. // ---------------------------------------------------------------------------- lglw_swap_buffers

  1540. void lglw_swap_buffers(lglw_t _lglw) {

  1541.    LGLW(_lglw);

  1542. 

  1543.    if(NULL != lglw)

  1544.    {

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

  1546.       {

  1547.          Dlog_vv("lglw:lglw_swap_buffers: 1\n");

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

  1549.       }

  1550.    }

  1551. }

  1552. 

  1553. 

  1554. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  1557.    LGLW(_lglw);

  1558. 

  1559.    if(NULL != lglw)

  1560.    {

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

  1562.       {

  1563.          Dlog_vv("lglw:lglw_swap_interval_set: 1\n");

  1564.          PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  1566.          if(NULL != glXSwapIntervalEXT)

  1567.          {

  1568.             Dlog_vv("lglw:lglw_swap_interval_set: 2\n");

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

  1570.             lglw->win.swap_interval = _ival;

  1571.          }

  1572.       }

  1573.    }

  1574. }

  1575. 

  1576. 

  1577. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  1578. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  1579.    LGLW(_lglw);

  1580.    int32_t r = 0;

  1581. 

  1582.    if(NULL != lglw)

  1583.    {

  1584.       r = lglw->win.swap_interval;

  1585.    }

  1586. 

  1587.    return r;

  1588. }

  1589. 

  1590. 

  1591. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  1592. static void loc_handle_mouseleave(lglw_int_t *lglw) {

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

  1594. 

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

  1596.    {

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

  1598.    }

  1599. 

  1600.    Dlog_vv("xxx lglw:loc_handle_mouseleave: LEAVE\n");

  1601. }

  1602. 

  1603. 

  1604. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  1605. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  1606. 

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

  1608. 

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

  1610.    {

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

  1612.    }

  1613. 

  1614.    Dlog_vv("xxx lglw:loc_handle_mouseenter: LEAVE\n");

  1615. }

  1616. 

  1617. 

  1618. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  1620.    if(_bPressed)

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

  1622.    else

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

  1624. 

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

  1626.    {

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

  1628.    }

  1629. }

  1630. 

  1631. 

  1632. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  1633. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  1634. 

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

  1636.    {

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

  1638.    }

  1639. }

  1640. 

  1641. 

  1642. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1644.    LGLW(_lglw);

  1645. 

  1646.    if(NULL != lglw)

  1647.    {

  1648.       lglw->mouse.cbk = _cbk;

  1649.    }

  1650. }

  1651. 

  1652. 

  1653. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1655.    LGLW(_lglw);

  1656. 

  1657.    if(NULL != lglw)

  1658.    {

  1659.       lglw->focus.cbk = _cbk;

  1660.    }

  1661. }

  1662. 

  1663. 

  1664. // ---------------------------------------------------------------------------- loc_handle_key

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

  1666.    lglw_bool_t r = LGLW_FALSE;

  1667. 

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

  1669.    {

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

  1671.    }

  1672. 

  1673.    return r;

  1674. }

  1675. 

  1676. 

  1677. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  1679.    LGLW(_lglw);

  1680. 

  1681.    if(NULL != lglw)

  1682.    {

  1683.       lglw->keyboard.cbk = _cbk;

  1684.    }

  1685. }

  1686. 

  1687. 

  1688. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  1689. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  1690.    uint32_t r = 0u;

  1691.    LGLW(_lglw);

  1692. 

  1693.    if(NULL != lglw)

  1694.    {

  1695.       r = lglw->keyboard.kmod_state;

  1696.    }

  1697. 

  1698.    return r;

  1699. }

  1700. 

  1701. 

  1702. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  1704.    LGLW(_lglw);

  1705. 

  1706.    // (todo) implement me

  1707. 

  1708.    if(NULL != lglw)

  1709.    {

  1710.    }

  1711. }

  1712. 

  1713. 

  1714. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  1715. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  1716.    uint32_t r = 0u;

  1717.    LGLW(_lglw);

  1718. 

  1719.    if(NULL != lglw)

  1720.    {

  1721.       r = lglw->mouse.button_state;

  1722.    }

  1723. 

  1724.    return r;

  1725. }

  1726. 

  1727. 

  1728. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  1730.    LGLW(_lglw);

  1731. 

  1732.    if(NULL != lglw)

  1733.    {

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

  1735.       {

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

  1737.          {

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

  1739.             {

  1740.                lglw_mouse_ungrab(_lglw);

  1741.             }

  1742. 

  1743.             int result;

  1744. 

  1745.             switch(_grabMode)

  1746.             {

  1747.                default:

  1748.                case LGLW_MOUSE_GRAB_NONE:

  1749.                   break;

  1750. 

  1751.                case LGLW_MOUSE_GRAB_CAPTURE:

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

  1753.                                         True/*owner_events*/,

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

  1755.                                         GrabModeAsync/*pointer_mode*/,

  1756.                                         GrabModeAsync/*keyboard_mode*/,

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

  1758.                                         None/*cursor*/,

  1759.                                         CurrentTime/*time*/);

  1760.                   if(GrabSuccess != result)

  1761.                   {

  1762.                      Dlog("lglw: Grab Result: %i\n", result);

  1763.                   }

  1764.                   else

  1765.                   {

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

  1767.                   }

  1768.                   break;

  1769. 

  1770.                case LGLW_MOUSE_GRAB_WARP:

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

  1772.                                         True/*owner_events*/,

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

  1774.                                         GrabModeAsync/*pointer_mode*/,

  1775.                                         GrabModeAsync/*keyboard_mode*/,

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

  1777.                                         None/*cursor*/,

  1778.                                         CurrentTime/*time*/);

  1779.                   if(GrabSuccess != result)

  1780.                   {

  1781.                      Dlog("lglw: Grab Result: %i\n", result);

  1782.                   }

  1783.                   else

  1784.                   {

  1785.                      lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  1789.                   }

  1790.                   break;

  1791.             }

  1792.          }

  1793.       }

  1794.    }

  1795. }

  1796. 

  1797. 

  1798. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  1799. void lglw_mouse_ungrab(lglw_t _lglw) {

  1800.    LGLW(_lglw);

  1801. 

  1802.    if(NULL != lglw)

  1803.    {

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

  1805.       {

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

  1807.          {

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

  1809.             {

  1810.                default:

  1811.                case LGLW_MOUSE_GRAB_NONE:

  1812.                   break;

  1813. 

  1814.                case LGLW_MOUSE_GRAB_CAPTURE:

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

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

  1817.                   break;

  1818. 

  1819.                case LGLW_MOUSE_GRAB_WARP:

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

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

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

  1823.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1824.                   break;

  1825.             }

  1826.          }

  1827.       }

  1828.    }

  1829. }

  1830. 

  1831. 

  1832. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1834.    LGLW(_lglw);

  1835. 

  1836.    if(NULL != lglw)

  1837.    {

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

  1839.       {

  1840.          XWarpPointer(lglw->xdsp,

  1841.                       None/*src_w*/,

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

  1843.                       0/*src_x*/,

  1844.                       0/*src_y*/,

  1845.                       0/*src_width*/,

  1846.                       0/*src_height*/,

  1847.                       _x/*dest_x*/,

  1848.                       _y/*dest_y*/);

  1849.       }

  1850.    }

  1851. }

  1852. 

  1853. 

  1854. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1855. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1857.    {

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

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

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

  1861.    }

  1862. }

  1863. 

  1864. 

  1865. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1867.    LGLW(_lglw);

  1868. 

  1869.    if(NULL != lglw)

  1870.    {

  1871.       if(LGLW_FALSE == _bShow)

  1872.       {

  1873.          Pixmap noPxm;

  1874.          Cursor noCursor;

  1875.          XColor black, dummy;

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

  1877. 

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

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

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

  1881. 

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

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

  1884.          if(noPxm != None)

  1885.          {

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

  1887.          }

  1888.       }

  1889.       else

  1890.       {

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

  1892.       }

  1893.    }

  1894. }

  1895. 

  1896. 

  1897. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1899.    LGLW(_lglw);

  1900. 

  1901.    if(NULL != lglw)

  1902.    {

  1903.       Dlog_v("lglw:lglw_timer_start: interval=%u\n", _millisec);

  1904.       lglw->timer.interval_ms = _millisec;

  1905.       lglw->timer.b_running   = LGLW_TRUE;

  1906.    }

  1907. }

  1908. 

  1909. 

  1910. // ---------------------------------------------------------------------------- lglw_timer_stop

  1911. void lglw_timer_stop(lglw_t _lglw) {

  1912.    LGLW(_lglw);

  1913. 

  1914.    if(NULL != lglw)

  1915.    {

  1916.       Dlog_v("lglw:lglw_timer_stop\n");

  1917.       lglw->timer.b_running = LGLW_FALSE;

  1918.    }

  1919. }

  1920. 

  1921. 

  1922. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1924.    LGLW(_lglw);

  1925. 

  1926.    if(NULL != lglw)

  1927.    {

  1928.       lglw->timer.cbk = _cbk;

  1929.    }

  1930. }

  1931. 

  1932. 

  1933. // ---------------------------------------------------------------------------- loc_process_timer()

  1934. static void loc_process_timer(lglw_int_t *lglw) {

  1935.    if(lglw->timer.b_running)

  1936.    {

  1937.       uint32_t ms = loc_millisec_delta(lglw);

  1938. 

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

  1940.       {

  1941.          lglw->timer.last_ms = ms;

  1942. 

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

  1944.          {

  1945.             Dlog_vvv("lglw: invoke timer callback\n");

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

  1947.          }

  1948.       }

  1949.    }

  1950. }

  1951. 

  1952. 

  1953. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1955. 

  1956.    // (todo) implement me

  1957. }

  1958. 

  1959. 

  1960. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1962.    LGLW(_lglw);

  1963. 

  1964.    if(NULL != _lglw)

  1965.    {

  1966.       lglw->dropfiles.cbk = _cbk;

  1967. 

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

  1969.    }

  1970. }

  1971. 

  1972. 

  1973. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1975.    LGLW(_lglw);

  1976. 

  1977.    if(NULL != _lglw)

  1978.    {

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

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

  1981.    }

  1982. }

  1983. 

  1984. 

  1985. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1986. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1987.    lglw_bool_t r = LGLW_FALSE;

  1988.    LGLW(_lglw);

  1989. 

  1990.    if(NULL != _lglw)

  1991.    {

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

  1993.    }

  1994. 

  1995.    return r;

  1996. }

  1997. 

  1998. 

  1999. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  2001.    LGLW(_lglw);

  2002.    (void)_numChars;

  2003. 

  2004.    if(NULL != _text)

  2005.    {

  2006.       if(NULL != _lglw)

  2007.       {

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

  2009.          {

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

  2011. 

  2012.             if(numChars > 0u)

  2013.             {

  2014.                lglw->clipboard.numChars = numChars;

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

  2016. 

  2017.                uint32_t i;

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

  2019.                {

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

  2021.                }

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

  2023. 

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

  2025. 

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

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

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

  2029.             }

  2030.          }

  2031.       }

  2032.    }

  2033. }

  2034. 

  2035. 

  2036. // ---------------------------------------------------------------------------- loc_is_clipboard_event

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

  2038.    return _xevent->type == SelectionNotify;

  2039. }

  2040. 

  2041. 

  2042. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  2044.    LGLW(_lglw);

  2045. 

  2046.    if(NULL != _retNumChars)

  2047.       *_retNumChars = 0u;

  2048. 

  2049.    if(NULL != _retText)

  2050.       *_retText = 0;

  2051. 

  2052.    if(_maxChars > 0u)

  2053.    {

  2054.       if(NULL != _lglw)

  2055.       {

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

  2057.          {

  2058.             Window owner;

  2059.             XEvent xev;

  2060.             XSelectionEvent *cbReq;

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

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

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

  2064. 

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

  2066.             if(owner == None)

  2067.             {

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

  2069.                return;

  2070.             }

  2071. 

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

  2073.             {

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

  2075. 

  2076.                uint32_t i = 0u;

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

  2078.                {

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

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

  2081.                      break;

  2082.                }

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

  2084. 

  2085.                if(NULL != _retNumChars)

  2086.                   *_retNumChars = i;

  2087. 

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

  2089.                return;

  2090.             }

  2091. 

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

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

  2094. 

  2095.             cbReq = (XSelectionEvent*)&xev;

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

  2097.             {

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

  2099.                return;

  2100.             }

  2101. 

  2102.             Atom returnType;

  2103.             int returnFormat;

  2104.             unsigned long size, returnSize, bytesLeft;

  2105.             unsigned char *propertyValue = NULL;

  2106. 

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

  2108.                                0/*offset*/,

  2109.                                0/*length*/,

  2110.                                False/*delete*/,

  2111.                                AnyPropertyType/*req_type*/,

  2112.                                &returnType/*actual_type_return*/,

  2113.                                &returnFormat/*actual_format_return*/,

  2114.                                &returnSize/*nitems_return*/,

  2115.                                &size/*bytes_after_return*/,

  2116.                                &propertyValue/*prop_return*/);

  2117.             XFree(propertyValue);

  2118. 

  2119.             if(utf8 != returnType)

  2120.             {

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

  2122.                return;

  2123.             }

  2124. 

  2125.             if(8u != returnFormat)

  2126.             {

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

  2128.                return;

  2129.             }

  2130. 

  2131.             if(_maxChars < size)

  2132.                size = _maxChars;

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

  2134. 

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

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

  2137.                                0/*offset*/,

  2138.                                size/*length*/,

  2139.                                True/*delete*/,

  2140.                                AnyPropertyType/*req_type*/,

  2141.                                &returnType/*actual_type_return*/,

  2142.                                &returnFormat/*actual_format_return*/,

  2143.                                &returnSize/*nitems_return*/,

  2144.                                &bytesLeft/*bytes_after_return*/,

  2145.                                &propertyValue/*prop_return*/);

  2146. 

  2147.             if(returnSize == 0)

  2148.             {

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

  2150.                return;

  2151.             }

  2152. 

  2153.             uint32_t i = 0u;

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

  2155.             {

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

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

  2158.                   break;

  2159.             }

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

  2161. 

  2162.             if(NULL != _retNumChars)

  2163.                *_retNumChars = i;

  2164. 

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

  2166.             XFree(propertyValue);

  2167.          }

  2168.       }

  2169.    }

  2170. }

  2171. 

  2172. // ---------------------------------------------------------------------------- lglw_events

  2173. void lglw_events(lglw_t _lglw) {

  2174.    LGLW(_lglw);

  2175. 

  2176.    if(NULL != lglw)

  2177.    {

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

  2179.       {

  2180. #if 0

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

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

  2183.          // => numEv is always 0

  2184.          int evIdx = 0;

  2185.          Dlog_v("xxx lglw_events: numEv=%d\n", numEv);

  2186. 

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

  2188.          for(;;)

  2189.          {

  2190.             XEvent xev;

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

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

  2193.             loc_eventProc(&xev, lglw);

  2194.          }

  2195. #else

  2196.          // // int evIdx = 0;

  2197.          // // for(;;)

  2198.          // // {

  2199.          // //    XEvent xev;

  2200.          // //    // => blocks forever

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

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

  2203.          // // }

  2204. 

  2205.          loc_process_timer(lglw);

  2206. #endif

  2207.          

  2208.       }

  2209.    }

  2210. }