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

2214 lines
71KB
Raw Blame History 

  1. /* ----

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

  3.  * ---- author : bsp

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

  5.  * ----

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

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

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

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

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

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

  12.  * ----

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

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

  15.  * ----

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

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

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

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

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

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

  22.  * ---- THE SOFTWARE.

  23.  * ----

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

  25.  * ----

  26.  * ---- created: 04Aug2018

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

  28.  * ----

  29.  * ----

  30.  */

  31. 

  32. // #define USE_XEVENTPROC defined

  33. 

  34. #include "lglw.h"

  35. 

  36. #include <stdlib.h>

  37. #include <stdio.h>

  38. #include <string.h>

  39. #include <stdarg.h>

  40. 

  41. #include <X11/Xlib.h>

  42. #include <X11/Xutil.h>

  43. #include <X11/Xos.h>

  44. #include <X11/Xatom.h>

  45. 

  46. #include <GL/gl.h>

  47. #include <GL/glx.h>

  48. 

  49. #ifdef ARCH_X64

  50. #include <sys/mman.h>

  51. #include <unistd.h>

  52. #endif // ARCH_X64

  53. 

  54. 

  55. #define LOG_FXN  printf

  56. // #define LOG_FXN  lglw_log

  57. 

  58. //

  59. // Regular log entry (low frequency)

  60. //

  61. #define Dlog if(0);else LOG_FXN

  62. 

  63. //

  64. // Verbose log entry

  65. //

  66. #define Dlog_v if(0);else LOG_FXN

  67. 

  68. //

  69. // Very-verbose log entry

  70. //

  71. #define Dlog_vv if(1);else LOG_FXN

  72. 

  73. //

  74. // Very-very-verbose log entry

  75. //

  76. #define Dlog_vvv if(0);else LOG_FXN

  77. 

  78. //

  79. // Print to stdout

  80. //

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

  82. //

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

  84. 

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

  86. 

  87. // ---------------------------------------------------------------------------- macros and defines

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

  89. 

  90. #define LGLW_DEFAULT_HIDDEN_W  (800)

  91. #define LGLW_DEFAULT_HIDDEN_H  (600)

  92. 

  93. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  94. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  95. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  96. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  97. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  98. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  99. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  100. 

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

  102. 

  103. 

  104. // ---------------------------------------------------------------------------- structs and typedefs

  105. typedef struct lglw_int_s {

  106.    void        *user_data;    // arbitrary user data

  107.    Display     *xdsp;

  108.    XVisualInfo *vi;

  109.    Colormap     cmap;

  110.    Window       parent_xwnd;  // created by host

  111. 

  112.    struct {

  113.       lglw_vec2i_t size;

  114.       Window       xwnd;

  115.    } hidden;

  116. 

  117.    struct {

  118.       lglw_vec2i_t size;

  119.       Window       xwnd;

  120.       lglw_bool_t  mapped;

  121.       int32_t      swap_interval;

  122.       lglw_bool_t  b_owner;

  123.    } win;

  124. 

  125.    GLXContext   ctx;

  126. 

  127.    struct {

  128.       GLXContext   ctx;

  129.       GLXDrawable  drw;

  130.    } prev;

  131. 

  132.    struct {

  133.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  134.       lglw_keyboard_fxn_t cbk;

  135.    } keyboard;

  136. 

  137.    struct {

  138.       lglw_vec2i_t     p;  // last seen mouse position

  139.       uint32_t         button_state;

  140.       lglw_mouse_fxn_t cbk;

  141.       struct {

  142.          uint32_t         mode;

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

  144.          lglw_bool_t      b_queue_warp;

  145.          lglw_vec2i_t     last_p;

  146.       } grab;

  147.       struct {

  148.          lglw_bool_t      b_enable;

  149.          lglw_bool_t      b_update_queued;

  150.          lglw_bool_t      b_syn_rmb;

  151.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  152.          uint32_t         hold_start_ms;

  153.          lglw_vec2i_t     hold_start_p;

  154.       } touch;

  155.    } mouse;

  156. 

  157.    struct {

  158.       uint32_t         state;

  159.       lglw_focus_fxn_t cbk;

  160.    } focus;

  161. 

  162.    struct {

  163.       lglw_bool_t      b_running;

  164.       lglw_timer_fxn_t cbk;

  165.       struct timeval   tv_start;

  166.       uint32_t         interval_ms;

  167.       uint32_t         last_ms;

  168.    } timer;

  169. 

  170.    struct {

  171.       uint32_t numChars;

  172.       char *data;

  173.    } clipboard;

  174. 

  175.    struct {

  176.       lglw_dropfiles_fxn_t cbk;

  177.    } dropfiles;

  178. 

  179.    struct {

  180.       lglw_redraw_fxn_t cbk;

  181.    } redraw;

  182. 

  183. } lglw_int_t;

  184. 

  185. 

  186. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  188. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  189. 

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

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

  192. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  193. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  194. 

  195. static void loc_handle_mouseleave (lglw_int_t *lglw);

  196. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  198. static void loc_handle_mousemotion (lglw_int_t *lglw);

  199. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  200. 

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

  202. 

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

  204. static void loc_XEventProc (void *_xevent);

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

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

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

  208. 

  209. static void loc_millisec_init (lglw_int_t *lglw);

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

  211. static void loc_process_timer (lglw_int_t *lglw);

  212. 

  213. 

  214. // ---------------------------------------------------------------------------- lglw_millisec_init

  215. static void loc_millisec_init (lglw_int_t *lglw) {

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

  217. }

  218. 

  219. // ---------------------------------------------------------------------------- lglw_millisec_delta

  220. static uint32_t loc_millisec_delta (lglw_int_t *lglw) {

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

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

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

  224. }

  225. 

  226. 

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

  228. // ---------------------------------------------------------------------------- lglw_log

  229. static FILE *logfile;

  230. 

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

  232.    static char buf[16*1024]; 

  233.    va_list va; 

  234.    va_start(va, logData); 

  235.    vsprintf(buf, logData, va);

  236.    va_end(va); 

  237.    printf(buf); 

  238.    //fprintf(logfile, logData);

  239.    fputs(buf, logfile);

  240.    fflush(logfile);

  241.    // printf(logData);

  242. }

  243. 

  244. 

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

  246. // ---------------------------------------------------------------------------- xerror_log

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

  248.    char error_text[1024];

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

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

  251.    return 0;

  252. }

  253. 

  254. 

  255. // ---------------------------------------------------------------------------- lglw_init

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

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

  258. 

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

  260. 

  261.    // TODO: remove/improve

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

  263.    XSetErrorHandler(xerror_handler);

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

  265. 

  266.    loc_millisec_init(lglw);

  267. 

  268.    if(NULL != lglw)

  269.    {

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

  271. 

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

  273.       if(_w <= 16)

  274.          _w = LGLW_DEFAULT_HIDDEN_W;

  275. 

  276.       if(_h <= 16)

  277.          _h = LGLW_DEFAULT_HIDDEN_H;

  278. 

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

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

  281.       {

  282.          free(lglw);

  283.          lglw = NULL;

  284.       }

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

  286.    }

  287. 

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

  289. 

  290.    return lglw;

  291. }

  292. 

  293. 

  294. // ---------------------------------------------------------------------------- lglw_exit

  295. void lglw_exit(lglw_t _lglw) {

  296.    LGLW(_lglw);

  297. 

  298.    if(NULL != lglw)

  299.    {

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

  301. 

  302.       loc_destroy_hidden_window(lglw);

  303. 

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

  305. 

  306.       fclose(logfile);

  307.       free(lglw);

  308.    }

  309. }

  310. 

  311. 

  312. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  314.    LGLW(_lglw);

  315. 

  316.    if(NULL != lglw)

  317.    {

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

  319.       lglw->user_data = _userData;

  320.    }

  321. }

  322. 

  323. // ---------------------------------------------------------------------------- lglw_userdata_get

  324. void *lglw_userdata_get(lglw_t _lglw) {

  325.    LGLW(_lglw);

  326. 

  327.    if(NULL != lglw)

  328.    {

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

  330.       return lglw->user_data;

  331.    }

  332. 

  333.    return NULL;

  334. }

  335. 

  336. 

  337. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  339. 

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

  341. 

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

  343.    XSetWindowAttributes swa;

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

  345.    int screen;

  346. 

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

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

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

  350. 

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

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

  353. 

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

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

  356.    {

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

  358.       return LGLW_FALSE;

  359.    }

  360. 

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

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

  363. 

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

  365.    {

  366.       Dlog("lglw: FAILED to create context!!!\n");

  367.    }

  368. 

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

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

  371.    {

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

  373.       return LGLW_FALSE;

  374.    }

  375. 

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

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

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

  379. 

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

  381.    swa.border_pixel = 0;

  382.    swa.colormap = lglw->cmap;

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

  384.                                      0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  386. 

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

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

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

  390. 

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

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

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

  394. 

  395.    return LGLW_TRUE;

  396. }

  397. 

  398. 

  399. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  400. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  403.    {

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

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

  406.    }

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

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

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

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

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

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

  413. 

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

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

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

  417. }

  418. 

  419. 

  420. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  427. 

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

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

  430. 

  431.    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);

  432. 

  433.    loc_process_timer(lglw);

  434. 

  435.    if(NULL != lglw)

  436.    {

  437.       lglw_bool_t eventHandled = LGLW_FALSE;

  438. 

  439.       switch(xev->type)

  440.       {

  441.          default:

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

  443.             eventHandled = LGLW_FALSE;

  444.             break;

  445. 

  446.          case Expose:

  447.             Dlog_vv("lglw:loc_eventProc: xev Expose\n");

  448.             loc_handle_queued_mouse_warp(lglw);

  449.             eventHandled = LGLW_FALSE;

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

  451.             {

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

  453.                eventHandled = LGLW_TRUE;

  454.             }

  455.             break;

  456. 

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

  458. 

  459.          case FocusIn:

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

  461.             eventHandled = LGLW_FALSE;

  462.             break;

  463. 

  464.          case FocusOut:

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

  466.             eventHandled = LGLW_FALSE;

  467.             break;

  468. 

  469.          case EnterNotify:

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

  471.             ; // empty statement

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

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

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

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

  476.             loc_handle_mousemotion(lglw);

  477. 

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

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

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

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

  482.             {

  483.                loc_handle_mouseenter(lglw);

  484.             }

  485.             eventHandled = LGLW_TRUE;

  486. 

  487.             break;

  488. 

  489.          case LeaveNotify:

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

  491.             ; // empty statement

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

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

  494. 

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

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

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

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

  499.             {

  500.                loc_handle_mouseleave(lglw);

  501.             }

  502.             eventHandled = LGLW_TRUE;

  503. 

  504.             break;

  505. 

  506.          case MotionNotify:

  507.             Dlog_vvv("lglw:loc_eventProc: xev MotionNotify\n");

  508.             ; // empty statement

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

  510. 

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

  512.             {

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

  514. 

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

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

  517. 

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

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

  520.             }

  521.             else

  522.             {

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

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

  525.             }

  526. 

  527.             loc_handle_mousemotion(lglw);

  528.             eventHandled = LGLW_TRUE;

  529. 

  530.             break;

  531. 

  532.          case KeyPress:

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

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

  535. 

  536.             eventHandled = LGLW_FALSE;

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

  538.             switch(xkp)

  539.             {

  540.                default:

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

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

  543.                   {

  544.                      KeySym xkpl;

  545.                      KeySym xkpu;

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

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

  548.                   }

  549.                   else

  550.                   {

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

  552.                   }

  553.                   break;

  554. 

  555.                case NoSymbol:

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

  557.                   break;

  558. 

  559.                case XK_Left:

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

  561.                   break;

  562. 

  563.                case XK_Right:

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

  565.                   break;

  566. 

  567.                case XK_Up:

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

  569.                   break;

  570. 

  571.                case XK_Down:

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

  573.                   break;

  574. 

  575.                case XK_Insert:

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

  577.                   break;

  578. 

  579.                case XK_Delete:

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

  581.                   break;

  582. 

  583.                case XK_Home:

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

  585.                   break;

  586. 

  587.                case XK_End:

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

  589.                   break;

  590. 

  591.                case XK_Prior:

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

  593.                   break;

  594. 

  595.                case XK_Next:

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

  597.                   break;

  598. 

  599.                case XK_F1:

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

  601.                   break;

  602. 

  603.                case XK_F2:

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

  605.                   break;

  606. 

  607.                case XK_F3:

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

  609.                   break;

  610. 

  611.                case XK_F4:

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

  613.                   break;

  614. 

  615.                case XK_F5:

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

  617.                   break;

  618. 

  619.                case XK_F6:

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

  621.                   break;

  622. 

  623.                case XK_F7:

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

  625.                   break;

  626. 

  627.                case XK_F8:

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

  629.                   break;

  630. 

  631.                case XK_F9:

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

  633.                   break;

  634. 

  635.                case XK_F10:

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

  637.                   break;

  638. 

  639.                case XK_F11:

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

  641.                   break;

  642. 

  643.                case XK_F12:

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

  645.                   break;

  646. 

  647.                case XK_BackSpace:

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

  649.                   break;

  650. 

  651.                case XK_Tab:

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

  653.                   break;

  654. 

  655.                case XK_Return:

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

  657.                   break;

  658. 

  659.                case XK_Escape:

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

  661.                   break;

  662. 

  663.                case XK_Shift_L:

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

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

  666.                   eventHandled = LGLW_FALSE;

  667.                   break;

  668. 

  669.                case XK_Shift_R:

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

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

  672.                   eventHandled = LGLW_FALSE;

  673.                   break;

  674. 

  675.                case XK_Control_L:

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

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

  678.                   eventHandled = LGLW_FALSE;

  679.                   break;

  680. 

  681.                case XK_Control_R:

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

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

  684.                   eventHandled = LGLW_FALSE;

  685.                   break;

  686.             }

  687. 

  688.             break;

  689. 

  690.          case KeyRelease:

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

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

  693. 

  694.             eventHandled = LGLW_FALSE;

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

  696.             switch(xkr)

  697.             {

  698.                default:

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

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

  701.                   {

  702.                      KeySym xkrl;

  703.                      KeySym xkru;

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

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

  706.                   }

  707.                   else

  708.                   {

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

  710.                   }

  711.                   break;

  712. 

  713.                case NoSymbol:

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

  715.                   break;

  716. 

  717.                case XK_Left:

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

  719.                   break;

  720. 

  721.                case XK_Right:

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

  723.                   break;

  724. 

  725.                case XK_Up:

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

  727.                   break;

  728. 

  729.                case XK_Down:

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

  731.                   break;

  732. 

  733.                case XK_Insert:

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

  735.                   break;

  736. 

  737.                case XK_Delete:

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

  739.                   break;

  740. 

  741.                case XK_Home:

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

  743.                   break;

  744. 

  745.                case XK_End:

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

  747.                   break;

  748. 

  749.                case XK_Prior:

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

  751.                   break;

  752. 

  753.                case XK_Next:

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

  755.                   break;

  756. 

  757.                case XK_F1:

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

  759.                   break;

  760. 

  761.                case XK_F2:

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

  763.                   break;

  764. 

  765.                case XK_F3:

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

  767.                   break;

  768. 

  769.                case XK_F4:

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

  771.                   break;

  772. 

  773.                case XK_F5:

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

  775.                   break;

  776. 

  777.                case XK_F6:

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

  779.                   break;

  780. 

  781.                case XK_F7:

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

  783.                   break;

  784. 

  785.                case XK_F8:

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

  787.                   break;

  788. 

  789.                case XK_F9:

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

  791.                   break;

  792. 

  793.                case XK_F10:

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

  795.                   break;

  796. 

  797.                case XK_F11:

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

  799.                   break;

  800. 

  801.                case XK_F12:

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

  803.                   break;

  804. 

  805.                case XK_BackSpace:

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

  807.                   break;

  808. 

  809.                case XK_Tab:

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

  811.                   break;

  812. 

  813.                case XK_Return:

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

  815.                   break;

  816. 

  817.                case XK_Escape:

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

  819.                   break;

  820. 

  821.                case XK_Shift_L:

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

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

  824.                   eventHandled = LGLW_FALSE;

  825.                   break;

  826. 

  827.                case XK_Shift_R:

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

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

  830.                   eventHandled = LGLW_FALSE;

  831.                   break;

  832. 

  833.                case XK_Control_L:

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

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

  836.                   eventHandled = LGLW_FALSE;

  837.                   break;

  838. 

  839.                case XK_Control_R:

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

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

  842.                   eventHandled = LGLW_FALSE;

  843.                   break;

  844.             }

  845. 

  846.             break;

  847. 

  848.          case ButtonPress:

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

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

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

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

  853. 

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

  855.             {

  856.                loc_handle_mouseenter(lglw);

  857.             }

  858. 

  859.             switch(btnPress->button)

  860.             {

  861.                default:

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

  863.                   eventHandled = LGLW_FALSE;

  864.                   break;

  865.                case Button1:

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

  867.                   eventHandled = LGLW_TRUE;

  868.                   break;

  869.                case Button2:

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

  871.                   eventHandled = LGLW_TRUE;

  872.                   break;

  873.                case Button3:

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

  875.                   eventHandled = LGLW_TRUE;

  876.                   break;

  877.                case Button4:

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

  879.                   eventHandled = LGLW_TRUE;

  880.                   break;

  881.                case Button5:

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

  883.                   eventHandled = LGLW_TRUE;

  884.                   break;

  885.             }

  886.             break;

  887. 

  888.          case ButtonRelease:

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

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

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

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

  893.             switch(btnRelease->button)

  894.             {

  895.                default:

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

  897.                   eventHandled = LGLW_FALSE;

  898.                   break;

  899.                case Button1:

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

  901.                   eventHandled = LGLW_TRUE;

  902.                   break;

  903.                case Button2:

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

  905.                   eventHandled = LGLW_TRUE;

  906.                   break;

  907.                case Button3:

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

  909.                   eventHandled = LGLW_TRUE;

  910.                   break;

  911.                case Button4:

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

  913.                   eventHandled = LGLW_TRUE;

  914.                   break;

  915.                case Button5:

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

  917.                   eventHandled = LGLW_TRUE;

  918.                   break;

  919.             }

  920.             break;

  921. 

  922.          case SelectionClear:

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

  924.             lglw->clipboard.numChars = 0;

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

  926.             eventHandled = LGLW_TRUE;

  927.             break;

  928. 

  929.          case SelectionRequest:

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

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

  932.             XSelectionEvent cbRes;

  933. 

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

  935. 

  936.             cbRes.type = SelectionNotify;

  937.             cbRes.requestor = cbReq->requestor;

  938.             cbRes.selection = cbReq->selection;

  939.             cbRes.target = cbReq->target;

  940.             cbRes.time = cbReq->time;

  941. 

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

  943.             {

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

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

  946. 

  947.                cbRes.property = cbReq->property;

  948.             }

  949.             else

  950.             {

  951.                cbRes.property = None;

  952.             }

  953. 

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

  955.             eventHandled = LGLW_TRUE;

  956. 

  957.             break;

  958.       }

  959. 

  960.       if(LGLW_FALSE == eventHandled)

  961.       {

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

  963.          {

  964.             Dlog("lglw:loc_eventProc: no parent window to send events to\n");

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

  966.          }

  967.          else

  968.          {

  969.             Dlog("lglw:loc_eventProc: sending event %i to parent\n", xev->type);

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

  971.          }

  972.       }

  973.    }

  974. }

  975. 

  976. static void loc_XEventProc(void *_xevent) {

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

  978. 

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

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

  981. 

  982.    if(NULL != xev)

  983.    {

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

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

  986. 

  987.       loc_eventProc(xev, lglw);

  988.    }

  989. 

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

  991. }

  992. 

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

  994.    size_t data = (size_t)_value;

  995.    long temp[2];

  996. 

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

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

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

  1000. 

  1001.    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]);

  1002. 

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

  1004. 

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

  1006.    XChangeProperty(_display, _window,

  1007.                    atom/*property*/,

  1008.                    atom/*type*/,

  1009.                    32/*format*/,

  1010.                    PropModeReplace/*mode*/,

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

  1012.                    2/*nelements*/

  1013.                    );

  1014. }

  1015. 

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

  1017.    int userSize;

  1018.    unsigned long bytes;

  1019.    unsigned long userCount;

  1020.    unsigned char *data;

  1021.    Atom userType;

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

  1023. 

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

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

  1026.    XGetWindowProperty(_display,

  1027.                       _window,

  1028.                       atom,

  1029.                       0/*offset*/,

  1030.                       1/*length*/,

  1031.                       False/*delete*/,

  1032.                       AnyPropertyType,

  1033.                       &userType/*actual_type_return*/,

  1034.                       &userSize/*actual_format_return*/,

  1035.                       &userCount/*nitems_return*/,

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

  1037.                       &data);

  1038. 

  1039.    union {

  1040.       uint32_t ui[2];

  1041.       void *any;

  1042.    } uptr;

  1043.    uptr.any = 0;

  1044. 

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

  1046. 

  1047.    if(NULL != data)

  1048.    {

  1049.       if(userCount >= 1)

  1050.       {

  1051.          // lower 32-bit

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

  1053.          uptr.ui[1] = 0;

  1054. 

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

  1056. 

  1057.          XFree(data);

  1058. 

  1059.          XGetWindowProperty(_display,

  1060.                             _window,

  1061.                             atom,

  1062.                             1/*offset*/,

  1063.                             1/*length*/,

  1064.                             False/*delete*/,

  1065.                             AnyPropertyType,

  1066.                             &userType/*actual_type_return*/,

  1067.                             &userSize/*actual_format_return*/,

  1068.                             &userCount/*nitems_return*/,

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

  1070.                             &data);

  1071. 

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

  1073.          if(NULL != data)

  1074.          {

  1075.             // upper 32-bit

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

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

  1078.             XFree(data);

  1079.          }

  1080.       }

  1081.    }

  1082. 

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

  1084. 

  1085.    return uptr.any;

  1086. }

  1087. 

  1088. 

  1089. #ifdef ARCH_X64

  1090. #if 0

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

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

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

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

  1095.    size_t data = (size_t)loc_eventProc;

  1096.    long temp[2];

  1097. 

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

  1099. 

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

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

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

  1103. 

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

  1105.    XChangeProperty(display, window,

  1106.                    atom/*property*/,

  1107.                    atom/*type*/,

  1108.                    32/*format*/,

  1109.                    PropModeReplace/*mode*/,

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

  1111.                    2/*nelements*/

  1112.                    );

  1113. }

  1114. #else

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

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

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

  1118.    //

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

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

  1121.    //

  1122. 

  1123.    // based on mach_override

  1124.    static const unsigned char kJumpInstructions[] = {

  1125.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  1126.          0x00, 0x00, 0x00, 0x00,

  1127.          0x00, 0x00, 0x00, 0x00

  1128.    };

  1129.    static const int kJumpAddress = 6;

  1130. 

  1131.    static char *ptr = 0;

  1132.    if (!ptr) {

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

  1134.                          getpagesize()/*PAGE_SIZE*/,

  1135.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  1136.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  1137.                          0, 0);

  1138.       if (ptr == MAP_FAILED) {

  1139.          perror("mmap");

  1140.          ptr = 0;

  1141.          return;

  1142.       } else {

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

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

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

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

  1147.       }

  1148.    }

  1149. 

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

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

  1152.    XChangeProperty(display, window,

  1153.                    atom/*property*/,

  1154.                    atom/*type*/,

  1155.                    32/*format*/,

  1156.                    PropModeReplace/*mode*/,

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

  1158.                    2/*nelements*/

  1159.                    );

  1160. }

  1161. #endif

  1162. #else

  1163. // Pulled from the eXT2 example

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

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

  1166. 

  1167.    // (note) 32-bit only

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

  1169.    XChangeProperty(display, window,

  1170.                    atom/*property*/,

  1171.                    atom/*type*/,

  1172.                    32/*format*/,

  1173.                    PropModeReplace/*mode*/,

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

  1175.                    1/*nelements*/

  1176.                    );

  1177. }

  1178. #endif // ARCH_X64

  1179. 

  1180. 

  1181. // ---------------------------------------------------------------------------- lglw_window_open

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

  1183.    lglw_bool_t r = LGLW_FALSE;

  1184.    LGLW(_lglw);

  1185. 

  1186.    if(NULL != lglw)

  1187.    {

  1188.       Dlog_v("lglw:lglw_window_open: 1, %p, %i p=(%d; %d) s=(%d; %d)\n", (Window)_parentHWNDOrNull, (Window)_parentHWNDOrNull, _x, _y, _w, _h);

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

  1190. 

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

  1192.       if(_w <= 16)

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

  1194. 

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

  1196.       if(_h <= 16)

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

  1198. 

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

  1200. 

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

  1202.       XSetWindowAttributes swa;

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

  1204. 

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

  1206.       swa.border_pixel = 0;

  1207.       swa.colormap = lglw->cmap;

  1208.       swa.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask | ExposureMask | FocusChangeMask; // NoEventMask to bubble-up to parent

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

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

  1211.                                      0/*x*/,

  1212.                                      0/*y*/,

  1213.                                      _w/*width*/,

  1214.                                      _h/*height*/,

  1215.                                      0/*border_width*/,

  1216.                                      CopyFromParent/*depth*/,

  1217.                                      InputOutput/*class*/,

  1218.                                      lglw->vi->visual,

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

  1220.                                      &swa/*attributes*/

  1221.                                      );

  1222. 

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

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

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

  1226.                              "LGLW"/*window_name*/,

  1227.                              "LGLW"/*icon_name*/,

  1228.                              None/*icon_pixmap*/,

  1229.                              NULL/*argv*/,

  1230.                              0/*argc*/,

  1231.                              NULL/*XSizeHints*/

  1232.                              );

  1233. 

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

  1235. 

  1236. #ifdef USE_XEVENTPROC

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

  1238. #else

  1239.       {

  1240.          void *nowarn = &loc_setEventProc;

  1241.          (void)nowarn;

  1242.       }

  1243. #endif

  1244. 

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

  1246. 

  1247.       if(0 != _parentHWNDOrNull)

  1248.       {

  1249. #ifdef USE_XEVENTPROC

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

  1251. #endif // USE_XEVENTPROC

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

  1253.       }

  1254. 

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

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

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

  1258.       if (0 != _parentHWNDOrNull)

  1259.       {

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

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

  1262.       }

  1263. 

  1264.       lglw->win.b_owner = LGLW_TRUE;

  1265. 

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

  1267.       if(lglw->win.b_owner)

  1268.       {

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

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

  1271.       }

  1272. 

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

  1274.       lglw->win.mapped = LGLW_TRUE;

  1275. 

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

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

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

  1279. 

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

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

  1282. 

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

  1284. 

  1285.       r = LGLW_TRUE;

  1286.    }

  1287.    return r;

  1288. }

  1289. 

  1290. 

  1291. // ---------------------------------------------------------------------------- lglw_window_resize

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

  1293.    lglw_bool_t r = LGLW_FALSE;

  1294.    LGLW(_lglw);

  1295. 

  1296.    if(NULL != lglw)

  1297.    {

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

  1299.       {

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

  1301.          r = LGLW_TRUE;

  1302. 

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

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

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

  1306. 

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

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

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

  1310. 

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

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

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

  1314. 

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

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

  1317.          unsigned int num_children;

  1318. 

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

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

  1321.             return r;

  1322. 

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

  1324.          if(children)

  1325.             XFree((char *)children);

  1326. 

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

  1328.          // Resize parent window (if any)

  1329.          if(0 != parent)

  1330.          {

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

  1332.             int x, y;

  1333.             unsigned int width, height;

  1334.             unsigned int border_width;

  1335.             unsigned int depth;

  1336. 

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

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

  1339.                return r;

  1340. 

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

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

  1343.          }

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

  1345.       }

  1346.    }

  1347. 

  1348.    return r;

  1349. }

  1350. 

  1351. 

  1352. // ---------------------------------------------------------------------------- lglw_window_close

  1353. void lglw_window_close (lglw_t _lglw) {

  1354.    LGLW(_lglw);

  1355. 

  1356.    if(NULL != lglw)

  1357.    {

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

  1359.       {

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

  1361.          lglw_timer_stop(_lglw);

  1362. 

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

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

  1365. 

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

  1367.          if(lglw->win.b_owner)

  1368.          {

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

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

  1371.             lglw->win.b_owner = LGLW_FALSE;

  1372.          }

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

  1374.          lglw->win.xwnd = 0;

  1375.          lglw->win.mapped = LGLW_FALSE;

  1376. 

  1377.          {

  1378.             XEvent xev;

  1379.             int queued = XPending(lglw->xdsp);

  1380.             Dlog_vvv("lglw:lglw_window_close: consume %d pending events\n", queued);

  1381.             while(queued)

  1382.             {

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

  1384.                queued--;

  1385.             }

  1386.          }

  1387.       }

  1388.    }

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

  1390. }

  1391. 

  1392. 

  1393. // ---------------------------------------------------------------------------- lglw_window_show

  1394. void lglw_window_show(lglw_t _lglw) {

  1395.    LGLW(_lglw);

  1396. 

  1397.    if(NULL != lglw)

  1398.    {

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

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

  1401. 

  1402.       lglw->win.mapped = LGLW_TRUE;

  1403.    }

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

  1405. }

  1406. 

  1407. 

  1408. // ---------------------------------------------------------------------------- lglw_window_hide

  1409. void lglw_window_hide(lglw_t _lglw) {

  1410.    LGLW(_lglw);

  1411. 

  1412.    if(NULL != lglw)

  1413.    {

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

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

  1416. 

  1417.       lglw->win.mapped = LGLW_FALSE;

  1418.    }

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

  1420. }

  1421. 

  1422. 

  1423. // ---------------------------------------------------------------------------- lglw_window_is_visible

  1424. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  1425.    lglw_bool_t r = LGLW_FALSE;

  1426.    LGLW(_lglw);

  1427. 

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

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

  1430.    {

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

  1432.       r = lglw->win.mapped;

  1433.    }

  1434. 

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

  1436.    return r;

  1437. }

  1438. 

  1439. 

  1440. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  1442.    LGLW(_lglw);

  1443. 

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

  1445.    if(NULL != lglw)

  1446.    {

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

  1448.       {

  1449.          if(NULL != _retX)

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

  1451. 

  1452.          if(NULL != _retY)

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

  1454.       }

  1455.    }

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

  1457. }

  1458. 

  1459. 

  1460. // ---------------------------------------------------------------------------- lglw_redraw

  1461. void lglw_redraw(lglw_t _lglw) {

  1462.    LGLW(_lglw);

  1463. 

  1464.    if(NULL != lglw)

  1465.    {

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

  1467.       {

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

  1469.          XEvent xev;

  1470.          xev.xany.type       = Expose;

  1471.          xev.xany.serial     = 0;

  1472.          xev.xany.send_event = True;

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

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

  1475.          xev.xexpose.x      = 0;

  1476.          xev.xexpose.y      = 0;

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

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

  1479.          xev.xexpose.count  = 0;

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

  1481.                     True/*propagate*/,

  1482.                     ExposureMask/*event_mask*/,

  1483.                     &xev

  1484.                     );

  1485.          XFlush(lglw->xdsp);

  1486.       }

  1487.    }

  1488. }

  1489. 

  1490. 

  1491. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  1493.    LGLW(_lglw);

  1494. 

  1495.    if(NULL != lglw)

  1496.    {

  1497.       lglw->redraw.cbk = _cbk;

  1498.    }

  1499. }

  1500. 

  1501. 

  1502. // ---------------------------------------------------------------------------- lglw_glcontext_push

  1503. void lglw_glcontext_push(lglw_t _lglw) {

  1504.    LGLW(_lglw);

  1505. 

  1506.    if(NULL != lglw)

  1507.    {

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

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

  1510. 

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

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

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

  1514.       {

  1515.          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());

  1516.       }

  1517.       // Dlog_vvv("lglw:lglw_glcontext_push: LEAVE\n");

  1518.    }

  1519. }

  1520. 

  1521. 

  1522. // ---------------------------------------------------------------------------- lglw_glcontext_rebind

  1523. void lglw_glcontext_rebind(lglw_t _lglw) {

  1524.    LGLW(_lglw);

  1525.    // printf("xxx lglw_glcontext_rebind\n");

  1526. 

  1527.    if(NULL != lglw)

  1528.    {

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

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

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

  1532.       {

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

  1534.       }

  1535.    }

  1536. }

  1537. 

  1538. 

  1539. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  1540. void lglw_glcontext_pop(lglw_t _lglw) {

  1541.    LGLW(_lglw);

  1542. 

  1543.    if(NULL != lglw)

  1544.    {

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

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

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

  1548.       {

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

  1550.       }

  1551.    }

  1552. }

  1553. 

  1554. 

  1555. // ---------------------------------------------------------------------------- lglw_swap_buffers

  1556. void lglw_swap_buffers(lglw_t _lglw) {

  1557.    LGLW(_lglw);

  1558. 

  1559.    if(NULL != lglw)

  1560.    {

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

  1562.       {

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

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

  1565.       }

  1566.    }

  1567. }

  1568. 

  1569. 

  1570. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  1573.    LGLW(_lglw);

  1574. 

  1575.    if(NULL != lglw)

  1576.    {

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

  1578.       {

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

  1580.          PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  1582.          if(NULL != glXSwapIntervalEXT)

  1583.          {

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

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

  1586.             lglw->win.swap_interval = _ival;

  1587.          }

  1588.       }

  1589.    }

  1590. }

  1591. 

  1592. 

  1593. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  1594. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  1595.    LGLW(_lglw);

  1596.    int32_t r = 0;

  1597. 

  1598.    if(NULL != lglw)

  1599.    {

  1600.       r = lglw->win.swap_interval;

  1601.    }

  1602. 

  1603.    return r;

  1604. }

  1605. 

  1606. 

  1607. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  1608. static void loc_handle_mouseleave(lglw_int_t *lglw) {

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

  1610. 

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

  1612.    {

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

  1614.    }

  1615. 

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

  1617. }

  1618. 

  1619. 

  1620. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  1621. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  1622. 

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

  1624. 

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

  1626.    {

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

  1628.    }

  1629. 

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

  1631. }

  1632. 

  1633. 

  1634. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  1636.    if(_bPressed)

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

  1638.    else

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

  1640. 

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

  1642.    {

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

  1644.    }

  1645. }

  1646. 

  1647. 

  1648. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  1649. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  1650. 

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

  1652.    {

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

  1654.    }

  1655. }

  1656. 

  1657. 

  1658. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1660.    LGLW(_lglw);

  1661. 

  1662.    if(NULL != lglw)

  1663.    {

  1664.       lglw->mouse.cbk = _cbk;

  1665.    }

  1666. }

  1667. 

  1668. 

  1669. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1671.    LGLW(_lglw);

  1672. 

  1673.    if(NULL != lglw)

  1674.    {

  1675.       lglw->focus.cbk = _cbk;

  1676.    }

  1677. }

  1678. 

  1679. 

  1680. // ---------------------------------------------------------------------------- loc_handle_key

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

  1682.    lglw_bool_t r = LGLW_FALSE;

  1683. 

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

  1685.    {

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

  1687.    }

  1688. 

  1689.    return r;

  1690. }

  1691. 

  1692. 

  1693. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  1695.    LGLW(_lglw);

  1696. 

  1697.    if(NULL != lglw)

  1698.    {

  1699.       lglw->keyboard.cbk = _cbk;

  1700.    }

  1701. }

  1702. 

  1703. 

  1704. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  1705. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  1706.    uint32_t r = 0u;

  1707.    LGLW(_lglw);

  1708. 

  1709.    if(NULL != lglw)

  1710.    {

  1711.       r = lglw->keyboard.kmod_state;

  1712.    }

  1713. 

  1714.    return r;

  1715. }

  1716. 

  1717. 

  1718. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  1720.    LGLW(_lglw);

  1721. 

  1722.    // (todo) implement me

  1723. 

  1724.    if(NULL != lglw)

  1725.    {

  1726.    }

  1727. }

  1728. 

  1729. 

  1730. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  1731. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  1732.    uint32_t r = 0u;

  1733.    LGLW(_lglw);

  1734. 

  1735.    if(NULL != lglw)

  1736.    {

  1737.       r = lglw->mouse.button_state;

  1738.    }

  1739. 

  1740.    return r;

  1741. }

  1742. 

  1743. 

  1744. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  1746.    LGLW(_lglw);

  1747. 

  1748.    if(NULL != lglw)

  1749.    {

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

  1751.       {

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

  1753.          {

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

  1755.             {

  1756.                lglw_mouse_ungrab(_lglw);

  1757.             }

  1758. 

  1759.             int result;

  1760. 

  1761.             switch(_grabMode)

  1762.             {

  1763.                default:

  1764.                case LGLW_MOUSE_GRAB_NONE:

  1765.                   break;

  1766. 

  1767.                case LGLW_MOUSE_GRAB_CAPTURE:

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

  1769.                                         True/*owner_events*/,

  1770.                                         NoEventMask/*event_mask*/,

  1771.                                         GrabModeAsync/*pointer_mode*/,

  1772.                                         GrabModeAsync/*keyboard_mode*/,

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

  1774.                                         None/*cursor*/,

  1775.                                         CurrentTime/*time*/);

  1776.                   if(GrabSuccess != result)

  1777.                   {

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

  1779.                   }

  1780.                   else

  1781.                   {

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

  1783.                   }

  1784.                   break;

  1785. 

  1786.                case LGLW_MOUSE_GRAB_WARP:

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

  1788.                                         True/*owner_events*/,

  1789.                                         NoEventMask/*event_mask*/,

  1790.                                         GrabModeAsync/*pointer_mode*/,

  1791.                                         GrabModeAsync/*keyboard_mode*/,

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

  1793.                                         None/*cursor*/,

  1794.                                         CurrentTime/*time*/);

  1795.                   if(GrabSuccess != result)

  1796.                   {

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

  1798.                   }

  1799.                   else

  1800.                   {

  1801.                      lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  1805.                   }

  1806.                   break;

  1807.             }

  1808.          }

  1809.       }

  1810.    }

  1811. }

  1812. 

  1813. 

  1814. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  1815. void lglw_mouse_ungrab(lglw_t _lglw) {

  1816.    LGLW(_lglw);

  1817. 

  1818.    if(NULL != lglw)

  1819.    {

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

  1821.       {

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

  1823.          {

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

  1825.             {

  1826.                default:

  1827.                case LGLW_MOUSE_GRAB_NONE:

  1828.                   break;

  1829. 

  1830.                case LGLW_MOUSE_GRAB_CAPTURE:

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

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

  1833.                   break;

  1834. 

  1835.                case LGLW_MOUSE_GRAB_WARP:

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

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

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

  1839.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1840.                   break;

  1841.             }

  1842.          }

  1843.       }

  1844.    }

  1845. }

  1846. 

  1847. 

  1848. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1850.    LGLW(_lglw);

  1851. 

  1852.    if(NULL != lglw)

  1853.    {

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

  1855.       {

  1856.          XWarpPointer(lglw->xdsp,

  1857.                       None/*src_w*/,

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

  1859.                       0/*src_x*/,

  1860.                       0/*src_y*/,

  1861.                       0/*src_width*/,

  1862.                       0/*src_height*/,

  1863.                       _x/*dest_x*/,

  1864.                       _y/*dest_y*/);

  1865.       }

  1866.    }

  1867. }

  1868. 

  1869. 

  1870. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1871. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1873.    {

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

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

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

  1877.    }

  1878. }

  1879. 

  1880. 

  1881. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1883.    LGLW(_lglw);

  1884. 

  1885.    if(NULL != lglw)

  1886.    {

  1887.       if(LGLW_FALSE == _bShow)

  1888.       {

  1889.          Pixmap noPxm;

  1890.          Cursor noCursor;

  1891.          XColor black, dummy;

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

  1893. 

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

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

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

  1897. 

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

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

  1900.          if(noPxm != None)

  1901.          {

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

  1903.          }

  1904.       }

  1905.       else

  1906.       {

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

  1908.       }

  1909.    }

  1910. }

  1911. 

  1912. 

  1913. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1915.    LGLW(_lglw);

  1916. 

  1917.    if(NULL != lglw)

  1918.    {

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

  1920.       lglw->timer.interval_ms = _millisec;

  1921.       lglw->timer.b_running   = LGLW_TRUE;

  1922.    }

  1923. }

  1924. 

  1925. 

  1926. // ---------------------------------------------------------------------------- lglw_timer_stop

  1927. void lglw_timer_stop(lglw_t _lglw) {

  1928.    LGLW(_lglw);

  1929. 

  1930.    if(NULL != lglw)

  1931.    {

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

  1933.       lglw->timer.b_running = LGLW_FALSE;

  1934.    }

  1935. }

  1936. 

  1937. 

  1938. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1940.    LGLW(_lglw);

  1941. 

  1942.    if(NULL != lglw)

  1943.    {

  1944.       lglw->timer.cbk = _cbk;

  1945.    }

  1946. }

  1947. 

  1948. 

  1949. // ---------------------------------------------------------------------------- loc_process_timer()

  1950. static void loc_process_timer(lglw_int_t *lglw) {

  1951.    if(lglw->timer.b_running)

  1952.    {

  1953.       uint32_t ms = loc_millisec_delta(lglw);

  1954. 

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

  1956.       {

  1957.          lglw->timer.last_ms = ms;

  1958. 

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

  1960.          {

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

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

  1963.          }

  1964.       }

  1965.    }

  1966. }

  1967. 

  1968. 

  1969. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1971. 

  1972.    // (todo) implement me

  1973. }

  1974. 

  1975. 

  1976. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1978.    LGLW(_lglw);

  1979. 

  1980.    if(NULL != _lglw)

  1981.    {

  1982.       lglw->dropfiles.cbk = _cbk;

  1983. 

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

  1985.    }

  1986. }

  1987. 

  1988. 

  1989. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1991.    LGLW(_lglw);

  1992. 

  1993.    if(NULL != _lglw)

  1994.    {

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

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

  1997.    }

  1998. }

  1999. 

  2000. 

  2001. // ---------------------------------------------------------------------------- lglw_touchinput_get

  2002. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  2003.    lglw_bool_t r = LGLW_FALSE;

  2004.    LGLW(_lglw);

  2005. 

  2006.    if(NULL != _lglw)

  2007.    {

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

  2009.    }

  2010. 

  2011.    return r;

  2012. }

  2013. 

  2014. 

  2015. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  2017.    LGLW(_lglw);

  2018.    (void)_numChars;

  2019. 

  2020.    if(NULL != _text)

  2021.    {

  2022.       if(NULL != _lglw)

  2023.       {

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

  2025.          {

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

  2027. 

  2028.             if(numChars > 0u)

  2029.             {

  2030.                lglw->clipboard.numChars = numChars;

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

  2032. 

  2033.                uint32_t i;

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

  2035.                {

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

  2037.                }

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

  2039. 

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

  2041. 

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

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

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

  2045.             }

  2046.          }

  2047.       }

  2048.    }

  2049. }

  2050. 

  2051. 

  2052. // ---------------------------------------------------------------------------- loc_is_clipboard_event

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

  2054.    return _xevent->type == SelectionNotify;

  2055. }

  2056. 

  2057. 

  2058. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  2060.    LGLW(_lglw);

  2061. 

  2062.    if(NULL != _retNumChars)

  2063.       *_retNumChars = 0u;

  2064. 

  2065.    if(NULL != _retText)

  2066.       *_retText = 0;

  2067. 

  2068.    if(_maxChars > 0u)

  2069.    {

  2070.       if(NULL != _lglw)

  2071.       {

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

  2073.          {

  2074.             Window owner;

  2075.             XEvent xev;

  2076.             XSelectionEvent *cbReq;

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

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

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

  2080. 

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

  2082.             if(owner == None)

  2083.             {

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

  2085.                return;

  2086.             }

  2087. 

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

  2089.             {

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

  2091. 

  2092.                uint32_t i = 0u;

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

  2094.                {

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

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

  2097.                      break;

  2098.                }

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

  2100. 

  2101.                if(NULL != _retNumChars)

  2102.                   *_retNumChars = i;

  2103. 

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

  2105.                return;

  2106.             }

  2107. 

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

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

  2110. 

  2111.             cbReq = (XSelectionEvent*)&xev;

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

  2113.             {

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

  2115.                return;

  2116.             }

  2117. 

  2118.             Atom returnType;

  2119.             int returnFormat;

  2120.             unsigned long size, returnSize, bytesLeft;

  2121.             unsigned char *propertyValue = NULL;

  2122. 

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

  2124.                                0/*offset*/,

  2125.                                0/*length*/,

  2126.                                False/*delete*/,

  2127.                                AnyPropertyType/*req_type*/,

  2128.                                &returnType/*actual_type_return*/,

  2129.                                &returnFormat/*actual_format_return*/,

  2130.                                &returnSize/*nitems_return*/,

  2131.                                &size/*bytes_after_return*/,

  2132.                                &propertyValue/*prop_return*/);

  2133.             XFree(propertyValue);

  2134. 

  2135.             if(utf8 != returnType)

  2136.             {

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

  2138.                return;

  2139.             }

  2140. 

  2141.             if(8u != returnFormat)

  2142.             {

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

  2144.                return;

  2145.             }

  2146. 

  2147.             if(_maxChars < size)

  2148.                size = _maxChars;

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

  2150. 

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

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

  2153.                                0/*offset*/,

  2154.                                size/*length*/,

  2155.                                True/*delete*/,

  2156.                                AnyPropertyType/*req_type*/,

  2157.                                &returnType/*actual_type_return*/,

  2158.                                &returnFormat/*actual_format_return*/,

  2159.                                &returnSize/*nitems_return*/,

  2160.                                &bytesLeft/*bytes_after_return*/,

  2161.                                &propertyValue/*prop_return*/);

  2162. 

  2163.             if(returnSize == 0)

  2164.             {

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

  2166.                return;

  2167.             }

  2168. 

  2169.             uint32_t i = 0u;

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

  2171.             {

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

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

  2174.                   break;

  2175.             }

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

  2177. 

  2178.             if(NULL != _retNumChars)

  2179.                *_retNumChars = i;

  2180. 

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

  2182.             XFree(propertyValue);

  2183.          }

  2184.       }

  2185.    }

  2186. }

  2187. 

  2188. 

  2189. // ---------------------------------------------------------------------------- lglw_events

  2190. void lglw_events(lglw_t _lglw) {

  2191.    LGLW(_lglw);

  2192. 

  2193.    if(NULL != lglw)

  2194.    {

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

  2196.       {

  2197.          XEvent xev;

  2198.          int queued = XPending(lglw->xdsp);

  2199.          if(queued > 0)

  2200.          {

  2201.             Dlog_vvv("lglw:lglw_events: (events: %i)\n", queued);

  2202.          }

  2203.          while(queued)

  2204.          {

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

  2206.             loc_eventProc(&xev, lglw);

  2207.             queued--;

  2208.          }

  2209. 

  2210.          loc_process_timer(lglw);

  2211.       }

  2212.    }

  2213. }