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

2211 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. // Regular log entry (low frequency)

  56. //

  57. // #define Dlog_verbose if(1);else printf

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

  59. 

  60. //

  61. // Verbose log entry

  62. //

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

  64. 

  65. //

  66. // Very-verbose log entry

  67. //

  68. #define Dlog_vv if(1);else lglw_log

  69. 

  70. //

  71. // Very-very-verbose log entry

  72. //

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

  74. 

  75. //

  76. // Print to stdout

  77. //

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

  79. //

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

  81. 

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

  83. 

  84. // ---------------------------------------------------------------------------- macros and defines

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

  86. 

  87. #define LGLW_DEFAULT_HIDDEN_W  (800)

  88. #define LGLW_DEFAULT_HIDDEN_H  (600)

  89. 

  90. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  91. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  92. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  93. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  94. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  95. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  96. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  97. 

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

  99. 

  100. 

  101. // ---------------------------------------------------------------------------- structs and typedefs

  102. typedef struct lglw_int_s {

  103.    void        *user_data;    // arbitrary user data

  104.    Display     *xdsp;

  105.    XVisualInfo *vi;

  106.    Colormap     cmap;

  107.    Window       parent_xwnd;  // created by host

  108. 

  109.    struct {

  110.       lglw_vec2i_t size;

  111.       Window       xwnd;

  112.    } hidden;

  113. 

  114.    struct {

  115.       lglw_vec2i_t size;

  116.       Window       xwnd;

  117.       lglw_bool_t  mapped;

  118.       int32_t      swap_interval;

  119.       lglw_bool_t  b_owner;

  120.    } win;

  121. 

  122.    GLXContext   ctx;

  123. 

  124.    struct {

  125.       GLXContext   ctx;

  126.       GLXDrawable  drw;

  127.    } prev;

  128. 

  129.    struct {

  130.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  131.       lglw_keyboard_fxn_t cbk;

  132.    } keyboard;

  133. 

  134.    struct {

  135.       lglw_vec2i_t     p;  // last seen mouse position

  136.       uint32_t         button_state;

  137.       lglw_mouse_fxn_t cbk;

  138.       struct {

  139.          uint32_t         mode;

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

  141.          lglw_bool_t      b_queue_warp;

  142.          lglw_vec2i_t     last_p;

  143.       } grab;

  144.       struct {

  145.          lglw_bool_t      b_enable;

  146.          lglw_bool_t      b_update_queued;

  147.          lglw_bool_t      b_syn_rmb;

  148.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  149.          uint32_t         hold_start_ms;

  150.          lglw_vec2i_t     hold_start_p;

  151.       } touch;

  152.    } mouse;

  153. 

  154.    struct {

  155.       uint32_t         state;

  156.       lglw_focus_fxn_t cbk;

  157.    } focus;

  158. 

  159.    struct {

  160.       lglw_bool_t      b_running;

  161.       lglw_timer_fxn_t cbk;

  162.       struct timeval   tv_start;

  163.       uint32_t         interval_ms;

  164.       uint32_t         last_ms;

  165.    } timer;

  166. 

  167.    struct {

  168.       uint32_t numChars;

  169.       char *data;

  170.    } clipboard;

  171. 

  172.    struct {

  173.       lglw_dropfiles_fxn_t cbk;

  174.    } dropfiles;

  175. 

  176.    struct {

  177.       lglw_redraw_fxn_t cbk;

  178.    } redraw;

  179. 

  180. } lglw_int_t;

  181. 

  182. 

  183. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  185. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  186. 

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

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

  189. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  190. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  191. 

  192. static void loc_handle_mouseleave (lglw_int_t *lglw);

  193. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  195. static void loc_handle_mousemotion (lglw_int_t *lglw);

  196. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  197. 

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

  199. 

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

  201. static void loc_XEventProc (void *_xevent);

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

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

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

  205. 

  206. static void loc_millisec_init (lglw_int_t *lglw);

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

  208. static void loc_process_timer (lglw_int_t *lglw);

  209. 

  210. 

  211. // ---------------------------------------------------------------------------- lglw_millisec_init

  212. static void loc_millisec_init (lglw_int_t *lglw) {

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

  214. }

  215. 

  216. // ---------------------------------------------------------------------------- lglw_millisec_delta

  217. static uint32_t loc_millisec_delta (lglw_int_t *lglw) {

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

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

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

  221. }

  222. 

  223. 

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

  225. // ---------------------------------------------------------------------------- lglw_log

  226. static FILE *logfile;

  227. 

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

  229.    static char buf[16*1024]; 

  230.    va_list va; 

  231.    va_start(va, logData); 

  232.    vsprintf(buf, logData, va);

  233.    va_end(va); 

  234.    printf(buf); 

  235.    //fprintf(logfile, logData);

  236.    fputs(buf, logfile);

  237.    fflush(logfile);

  238.    // printf(logData);

  239. }

  240. 

  241. 

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

  243. // ---------------------------------------------------------------------------- xerror_log

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

  245.    char error_text[1024];

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

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

  248.    return 0;

  249. }

  250. 

  251. 

  252. // ---------------------------------------------------------------------------- lglw_init

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

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

  255. 

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

  257. 

  258.    // TODO: remove/improve

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

  260.    XSetErrorHandler(xerror_handler);

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

  262. 

  263.    loc_millisec_init(lglw);

  264. 

  265.    if(NULL != lglw)

  266.    {

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

  268. 

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

  270.       if(_w <= 16)

  271.          _w = LGLW_DEFAULT_HIDDEN_W;

  272. 

  273.       if(_h <= 16)

  274.          _h = LGLW_DEFAULT_HIDDEN_H;

  275. 

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

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

  278.       {

  279.          free(lglw);

  280.          lglw = NULL;

  281.       }

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

  283.    }

  284. 

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

  286. 

  287.    return lglw;

  288. }

  289. 

  290. 

  291. // ---------------------------------------------------------------------------- lglw_exit

  292. void lglw_exit(lglw_t _lglw) {

  293.    LGLW(_lglw);

  294. 

  295.    if(NULL != lglw)

  296.    {

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

  298. 

  299.       loc_destroy_hidden_window(lglw);

  300. 

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

  302. 

  303.       fclose(logfile);

  304.       free(lglw);

  305.    }

  306. }

  307. 

  308. 

  309. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  311.    LGLW(_lglw);

  312. 

  313.    if(NULL != lglw)

  314.    {

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

  316.       lglw->user_data = _userData;

  317.    }

  318. }

  319. 

  320. // ---------------------------------------------------------------------------- lglw_userdata_get

  321. void *lglw_userdata_get(lglw_t _lglw) {

  322.    LGLW(_lglw);

  323. 

  324.    if(NULL != lglw)

  325.    {

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

  327.       return lglw->user_data;

  328.    }

  329. 

  330.    return NULL;

  331. }

  332. 

  333. 

  334. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  336. 

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

  338. 

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

  340.    XSetWindowAttributes swa;

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

  342.    int screen;

  343. 

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

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

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

  347. 

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

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

  350. 

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

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

  353.    {

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

  355.       return LGLW_FALSE;

  356.    }

  357. 

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

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

  360. 

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

  362.    {

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

  364.    }

  365. 

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

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

  368.    {

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

  370.       return LGLW_FALSE;

  371.    }

  372. 

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

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

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

  376. 

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

  378.    swa.border_pixel = 0;

  379.    swa.colormap = lglw->cmap;

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

  381.                                      0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  383. 

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

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

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

  387. 

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

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

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

  391. 

  392.    return LGLW_TRUE;

  393. }

  394. 

  395. 

  396. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  397. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  400.    {

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

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

  403.    }

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

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

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

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

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

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

  410. 

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

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

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

  414. }

  415. 

  416. 

  417. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  424. 

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

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

  427. 

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

  429. 

  430.    loc_process_timer(lglw);

  431. 

  432.    if(NULL != lglw)

  433.    {

  434.       lglw_bool_t eventHandled = LGLW_FALSE;

  435. 

  436.       switch(xev->type)

  437.       {

  438.          default:

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

  440.             eventHandled = LGLW_FALSE;

  441.             break;

  442. 

  443.          case Expose:

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

  445.             loc_handle_queued_mouse_warp(lglw);

  446.             eventHandled = LGLW_FALSE;

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

  448.             {

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

  450.                eventHandled = LGLW_TRUE;

  451.             }

  452.             break;

  453. 

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

  455. 

  456.          case FocusIn:

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

  458.             eventHandled = LGLW_FALSE;

  459.             break;

  460. 

  461.          case FocusOut:

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

  463.             eventHandled = LGLW_FALSE;

  464.             break;

  465. 

  466.          case EnterNotify:

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

  468.             ; // empty statement

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

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

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

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

  473.             loc_handle_mousemotion(lglw);

  474. 

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

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

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

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

  479.             {

  480.                loc_handle_mouseenter(lglw);

  481.             }

  482.             eventHandled = LGLW_TRUE;

  483. 

  484.             break;

  485. 

  486.          case LeaveNotify:

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

  488.             ; // empty statement

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

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

  491. 

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

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

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

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

  496.             {

  497.                loc_handle_mouseleave(lglw);

  498.             }

  499.             eventHandled = LGLW_TRUE;

  500. 

  501.             break;

  502. 

  503.          case MotionNotify:

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

  505.             ; // empty statement

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

  507. 

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

  509.             {

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

  511. 

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

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

  514. 

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

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

  517.             }

  518.             else

  519.             {

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

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

  522.             }

  523. 

  524.             loc_handle_mousemotion(lglw);

  525.             eventHandled = LGLW_TRUE;

  526. 

  527.             break;

  528. 

  529.          case KeyPress:

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

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

  532. 

  533.             eventHandled = LGLW_FALSE;

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

  535.             switch(xkp)

  536.             {

  537.                default:

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

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

  540.                   {

  541.                      KeySym xkpl;

  542.                      KeySym xkpu;

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

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

  545.                   }

  546.                   else

  547.                   {

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

  549.                   }

  550.                   break;

  551. 

  552.                case NoSymbol:

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

  554.                   break;

  555. 

  556.                case XK_Left:

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

  558.                   break;

  559. 

  560.                case XK_Right:

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

  562.                   break;

  563. 

  564.                case XK_Up:

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

  566.                   break;

  567. 

  568.                case XK_Down:

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

  570.                   break;

  571. 

  572.                case XK_Insert:

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

  574.                   break;

  575. 

  576.                case XK_Delete:

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

  578.                   break;

  579. 

  580.                case XK_Home:

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

  582.                   break;

  583. 

  584.                case XK_End:

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

  586.                   break;

  587. 

  588.                case XK_Prior:

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

  590.                   break;

  591. 

  592.                case XK_Next:

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

  594.                   break;

  595. 

  596.                case XK_F1:

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

  598.                   break;

  599. 

  600.                case XK_F2:

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

  602.                   break;

  603. 

  604.                case XK_F3:

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

  606.                   break;

  607. 

  608.                case XK_F4:

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

  610.                   break;

  611. 

  612.                case XK_F5:

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

  614.                   break;

  615. 

  616.                case XK_F6:

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

  618.                   break;

  619. 

  620.                case XK_F7:

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

  622.                   break;

  623. 

  624.                case XK_F8:

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

  626.                   break;

  627. 

  628.                case XK_F9:

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

  630.                   break;

  631. 

  632.                case XK_F10:

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

  634.                   break;

  635. 

  636.                case XK_F11:

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

  638.                   break;

  639. 

  640.                case XK_F12:

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

  642.                   break;

  643. 

  644.                case XK_BackSpace:

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

  646.                   break;

  647. 

  648.                case XK_Tab:

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

  650.                   break;

  651. 

  652.                case XK_Return:

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

  654.                   break;

  655. 

  656.                case XK_Escape:

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

  658.                   break;

  659. 

  660.                case XK_Shift_L:

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

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

  663.                   eventHandled = LGLW_FALSE;

  664.                   break;

  665. 

  666.                case XK_Shift_R:

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

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

  669.                   eventHandled = LGLW_FALSE;

  670.                   break;

  671. 

  672.                case XK_Control_L:

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

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

  675.                   eventHandled = LGLW_FALSE;

  676.                   break;

  677. 

  678.                case XK_Control_R:

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

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

  681.                   eventHandled = LGLW_FALSE;

  682.                   break;

  683.             }

  684. 

  685.             break;

  686. 

  687.          case KeyRelease:

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

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

  690. 

  691.             eventHandled = LGLW_FALSE;

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

  693.             switch(xkr)

  694.             {

  695.                default:

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

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

  698.                   {

  699.                      KeySym xkrl;

  700.                      KeySym xkru;

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

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

  703.                   }

  704.                   else

  705.                   {

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

  707.                   }

  708.                   break;

  709. 

  710.                case NoSymbol:

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

  712.                   break;

  713. 

  714.                case XK_Left:

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

  716.                   break;

  717. 

  718.                case XK_Right:

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

  720.                   break;

  721. 

  722.                case XK_Up:

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

  724.                   break;

  725. 

  726.                case XK_Down:

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

  728.                   break;

  729. 

  730.                case XK_Insert:

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

  732.                   break;

  733. 

  734.                case XK_Delete:

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

  736.                   break;

  737. 

  738.                case XK_Home:

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

  740.                   break;

  741. 

  742.                case XK_End:

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

  744.                   break;

  745. 

  746.                case XK_Prior:

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

  748.                   break;

  749. 

  750.                case XK_Next:

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

  752.                   break;

  753. 

  754.                case XK_F1:

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

  756.                   break;

  757. 

  758.                case XK_F2:

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

  760.                   break;

  761. 

  762.                case XK_F3:

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

  764.                   break;

  765. 

  766.                case XK_F4:

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

  768.                   break;

  769. 

  770.                case XK_F5:

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

  772.                   break;

  773. 

  774.                case XK_F6:

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

  776.                   break;

  777. 

  778.                case XK_F7:

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

  780.                   break;

  781. 

  782.                case XK_F8:

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

  784.                   break;

  785. 

  786.                case XK_F9:

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

  788.                   break;

  789. 

  790.                case XK_F10:

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

  792.                   break;

  793. 

  794.                case XK_F11:

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

  796.                   break;

  797. 

  798.                case XK_F12:

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

  800.                   break;

  801. 

  802.                case XK_BackSpace:

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

  804.                   break;

  805. 

  806.                case XK_Tab:

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

  808.                   break;

  809. 

  810.                case XK_Return:

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

  812.                   break;

  813. 

  814.                case XK_Escape:

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

  816.                   break;

  817. 

  818.                case XK_Shift_L:

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

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

  821.                   eventHandled = LGLW_FALSE;

  822.                   break;

  823. 

  824.                case XK_Shift_R:

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

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

  827.                   eventHandled = LGLW_FALSE;

  828.                   break;

  829. 

  830.                case XK_Control_L:

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

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

  833.                   eventHandled = LGLW_FALSE;

  834.                   break;

  835. 

  836.                case XK_Control_R:

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

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

  839.                   eventHandled = LGLW_FALSE;

  840.                   break;

  841.             }

  842. 

  843.             break;

  844. 

  845.          case ButtonPress:

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

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

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

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

  850. 

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

  852.             {

  853.                loc_handle_mouseenter(lglw);

  854.             }

  855. 

  856.             switch(btnPress->button)

  857.             {

  858.                default:

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

  860.                   eventHandled = LGLW_FALSE;

  861.                   break;

  862.                case Button1:

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

  864.                   eventHandled = LGLW_TRUE;

  865.                   break;

  866.                case Button2:

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

  868.                   eventHandled = LGLW_TRUE;

  869.                   break;

  870.                case Button3:

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

  872.                   eventHandled = LGLW_TRUE;

  873.                   break;

  874.                case Button4:

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

  876.                   eventHandled = LGLW_TRUE;

  877.                   break;

  878.                case Button5:

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

  880.                   eventHandled = LGLW_TRUE;

  881.                   break;

  882.             }

  883.             break;

  884. 

  885.          case ButtonRelease:

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

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

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

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

  890.             switch(btnRelease->button)

  891.             {

  892.                default:

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

  894.                   eventHandled = LGLW_FALSE;

  895.                   break;

  896.                case Button1:

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

  898.                   eventHandled = LGLW_TRUE;

  899.                   break;

  900.                case Button2:

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

  902.                   eventHandled = LGLW_TRUE;

  903.                   break;

  904.                case Button3:

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

  906.                   eventHandled = LGLW_TRUE;

  907.                   break;

  908.                case Button4:

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

  910.                   eventHandled = LGLW_TRUE;

  911.                   break;

  912.                case Button5:

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

  914.                   eventHandled = LGLW_TRUE;

  915.                   break;

  916.             }

  917.             break;

  918. 

  919.          case SelectionClear:

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

  921.             lglw->clipboard.numChars = 0;

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

  923.             eventHandled = LGLW_TRUE;

  924.             break;

  925. 

  926.          case SelectionRequest:

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

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

  929.             XSelectionEvent cbRes;

  930. 

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

  932. 

  933.             cbRes.type = SelectionNotify;

  934.             cbRes.requestor = cbReq->requestor;

  935.             cbRes.selection = cbReq->selection;

  936.             cbRes.target = cbReq->target;

  937.             cbRes.time = cbReq->time;

  938. 

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

  940.             {

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

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

  943. 

  944.                cbRes.property = cbReq->property;

  945.             }

  946.             else

  947.             {

  948.                cbRes.property = None;

  949.             }

  950. 

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

  952.             eventHandled = LGLW_TRUE;

  953. 

  954.             break;

  955.       }

  956. 

  957.       if(LGLW_FALSE == eventHandled)

  958.       {

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

  960.          {

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

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

  963.          }

  964.          else

  965.          {

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

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

  968.          }

  969.       }

  970.    }

  971. }

  972. 

  973. static void loc_XEventProc(void *_xevent) {

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

  975. 

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

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

  978. 

  979.    if(NULL != xev)

  980.    {

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

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

  983. 

  984.       loc_eventProc(xev, lglw);

  985.    }

  986. 

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

  988. }

  989. 

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

  991.    size_t data = (size_t)_value;

  992.    long temp[2];

  993. 

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

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

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

  997. 

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

  999. 

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

  1001. 

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

  1003.    XChangeProperty(_display, _window,

  1004.                    atom/*property*/,

  1005.                    atom/*type*/,

  1006.                    32/*format*/,

  1007.                    PropModeReplace/*mode*/,

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

  1009.                    2/*nelements*/

  1010.                    );

  1011. }

  1012. 

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

  1014.    int userSize;

  1015.    unsigned long bytes;

  1016.    unsigned long userCount;

  1017.    unsigned char *data;

  1018.    Atom userType;

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

  1020. 

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

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

  1023.    XGetWindowProperty(_display,

  1024.                       _window,

  1025.                       atom,

  1026.                       0/*offset*/,

  1027.                       1/*length*/,

  1028.                       False/*delete*/,

  1029.                       AnyPropertyType,

  1030.                       &userType/*actual_type_return*/,

  1031.                       &userSize/*actual_format_return*/,

  1032.                       &userCount/*nitems_return*/,

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

  1034.                       &data);

  1035. 

  1036.    union {

  1037.       uint32_t ui[2];

  1038.       void *any;

  1039.    } uptr;

  1040.    uptr.any = 0;

  1041. 

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

  1043. 

  1044.    if(NULL != data)

  1045.    {

  1046.       if(userCount >= 1)

  1047.       {

  1048.          // lower 32-bit

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

  1050.          uptr.ui[1] = 0;

  1051. 

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

  1053. 

  1054.          XFree(data);

  1055. 

  1056.          XGetWindowProperty(_display,

  1057.                             _window,

  1058.                             atom,

  1059.                             1/*offset*/,

  1060.                             1/*length*/,

  1061.                             False/*delete*/,

  1062.                             AnyPropertyType,

  1063.                             &userType/*actual_type_return*/,

  1064.                             &userSize/*actual_format_return*/,

  1065.                             &userCount/*nitems_return*/,

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

  1067.                             &data);

  1068. 

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

  1070.          if(NULL != data)

  1071.          {

  1072.             // upper 32-bit

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

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

  1075.             XFree(data);

  1076.          }

  1077.       }

  1078.    }

  1079. 

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

  1081. 

  1082.    return uptr.any;

  1083. }

  1084. 

  1085. 

  1086. #ifdef ARCH_X64

  1087. #if 0

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

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

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

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

  1092.    size_t data = (size_t)loc_eventProc;

  1093.    long temp[2];

  1094. 

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

  1096. 

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

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

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

  1100. 

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

  1102.    XChangeProperty(display, window,

  1103.                    atom/*property*/,

  1104.                    atom/*type*/,

  1105.                    32/*format*/,

  1106.                    PropModeReplace/*mode*/,

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

  1108.                    2/*nelements*/

  1109.                    );

  1110. }

  1111. #else

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

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

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

  1115.    //

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

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

  1118.    //

  1119. 

  1120.    // based on mach_override

  1121.    static const unsigned char kJumpInstructions[] = {

  1122.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  1123.          0x00, 0x00, 0x00, 0x00,

  1124.          0x00, 0x00, 0x00, 0x00

  1125.    };

  1126.    static const int kJumpAddress = 6;

  1127. 

  1128.    static char *ptr = 0;

  1129.    if (!ptr) {

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

  1131.                          getpagesize()/*PAGE_SIZE*/,

  1132.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  1133.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  1134.                          0, 0);

  1135.       if (ptr == MAP_FAILED) {

  1136.          perror("mmap");

  1137.          ptr = 0;

  1138.          return;

  1139.       } else {

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

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

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

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

  1144.       }

  1145.    }

  1146. 

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

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

  1149.    XChangeProperty(display, window,

  1150.                    atom/*property*/,

  1151.                    atom/*type*/,

  1152.                    32/*format*/,

  1153.                    PropModeReplace/*mode*/,

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

  1155.                    2/*nelements*/

  1156.                    );

  1157. }

  1158. #endif

  1159. #else

  1160. // Pulled from the eXT2 example

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

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

  1163. 

  1164.    // (note) 32-bit only

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

  1166.    XChangeProperty(display, window,

  1167.                    atom/*property*/,

  1168.                    atom/*type*/,

  1169.                    32/*format*/,

  1170.                    PropModeReplace/*mode*/,

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

  1172.                    1/*nelements*/

  1173.                    );

  1174. }

  1175. #endif // ARCH_X64

  1176. 

  1177. 

  1178. // ---------------------------------------------------------------------------- lglw_window_open

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

  1180.    lglw_bool_t r = LGLW_FALSE;

  1181.    LGLW(_lglw);

  1182. 

  1183.    if(NULL != lglw)

  1184.    {

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

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

  1187. 

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

  1189.       if(_w <= 16)

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

  1191. 

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

  1193.       if(_h <= 16)

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

  1195. 

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

  1197. 

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

  1199.       XSetWindowAttributes swa;

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

  1201. 

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

  1203.       swa.border_pixel = 0;

  1204.       swa.colormap = lglw->cmap;

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

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

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

  1208.                                      0/*x*/,

  1209.                                      0/*y*/,

  1210.                                      _w/*width*/,

  1211.                                      _h/*height*/,

  1212.                                      0/*border_width*/,

  1213.                                      CopyFromParent/*depth*/,

  1214.                                      InputOutput/*class*/,

  1215.                                      lglw->vi->visual,

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

  1217.                                      &swa/*attributes*/

  1218.                                      );

  1219. 

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

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

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

  1223.                              "LGLW"/*window_name*/,

  1224.                              "LGLW"/*icon_name*/,

  1225.                              None/*icon_pixmap*/,

  1226.                              NULL/*argv*/,

  1227.                              0/*argc*/,

  1228.                              NULL/*XSizeHints*/

  1229.                              );

  1230. 

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

  1232. 

  1233. #ifdef USE_XEVENTPROC

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

  1235. #else

  1236.       {

  1237.          void *nowarn = &loc_setEventProc;

  1238.          (void)nowarn;

  1239.       }

  1240. #endif

  1241. 

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

  1243. 

  1244.       if(0 != _parentHWNDOrNull)

  1245.       {

  1246. #ifdef USE_XEVENTPROC

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

  1248. #endif // USE_XEVENTPROC

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

  1250.       }

  1251. 

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

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

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

  1255.       if (0 != _parentHWNDOrNull)

  1256.       {

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

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

  1259.       }

  1260. 

  1261.       lglw->win.b_owner = LGLW_TRUE;

  1262. 

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

  1264.       if(lglw->win.b_owner)

  1265.       {

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

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

  1268.       }

  1269. 

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

  1271.       lglw->win.mapped = LGLW_TRUE;

  1272. 

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

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

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

  1276. 

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

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

  1279. 

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

  1281. 

  1282.       r = LGLW_TRUE;

  1283.    }

  1284.    return r;

  1285. }

  1286. 

  1287. 

  1288. // ---------------------------------------------------------------------------- lglw_window_resize

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

  1290.    lglw_bool_t r = LGLW_FALSE;

  1291.    LGLW(_lglw);

  1292. 

  1293.    if(NULL != lglw)

  1294.    {

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

  1296.       {

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

  1298.          r = LGLW_TRUE;

  1299. 

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

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

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

  1303. 

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

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

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

  1307. 

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

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

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

  1311. 

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

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

  1314.          unsigned int num_children;

  1315. 

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

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

  1318.             return r;

  1319. 

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

  1321.          if(children)

  1322.             XFree((char *)children);

  1323. 

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

  1325.          // Resize parent window (if any)

  1326.          if(0 != parent)

  1327.          {

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

  1329.             int x, y;

  1330.             unsigned int width, height;

  1331.             unsigned int border_width;

  1332.             unsigned int depth;

  1333. 

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

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

  1336.                return r;

  1337. 

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

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

  1340.          }

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

  1342.       }

  1343.    }

  1344. 

  1345.    return r;

  1346. }

  1347. 

  1348. 

  1349. // ---------------------------------------------------------------------------- lglw_window_close

  1350. void lglw_window_close (lglw_t _lglw) {

  1351.    LGLW(_lglw);

  1352. 

  1353.    if(NULL != lglw)

  1354.    {

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

  1356.       {

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

  1358.          lglw_timer_stop(_lglw);

  1359. 

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

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

  1362. 

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

  1364.          if(lglw->win.b_owner)

  1365.          {

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

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

  1368.             lglw->win.b_owner = LGLW_FALSE;

  1369.          }

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

  1371.          lglw->win.xwnd = 0;

  1372.          lglw->win.mapped = LGLW_FALSE;

  1373. 

  1374.          {

  1375.             XEvent xev;

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

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

  1378.             while(queued)

  1379.             {

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

  1381.                queued--;

  1382.             }

  1383.          }

  1384.       }

  1385.    }

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

  1387. }

  1388. 

  1389. 

  1390. // ---------------------------------------------------------------------------- lglw_window_show

  1391. void lglw_window_show(lglw_t _lglw) {

  1392.    LGLW(_lglw);

  1393. 

  1394.    if(NULL != lglw)

  1395.    {

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

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

  1398. 

  1399.       lglw->win.mapped = LGLW_TRUE;

  1400.    }

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

  1402. }

  1403. 

  1404. 

  1405. // ---------------------------------------------------------------------------- lglw_window_hide

  1406. void lglw_window_hide(lglw_t _lglw) {

  1407.    LGLW(_lglw);

  1408. 

  1409.    if(NULL != lglw)

  1410.    {

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

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

  1413. 

  1414.       lglw->win.mapped = LGLW_FALSE;

  1415.    }

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

  1417. }

  1418. 

  1419. 

  1420. // ---------------------------------------------------------------------------- lglw_window_is_visible

  1421. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  1422.    lglw_bool_t r = LGLW_FALSE;

  1423.    LGLW(_lglw);

  1424. 

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

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

  1427.    {

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

  1429.       r = lglw->win.mapped;

  1430.    }

  1431. 

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

  1433.    return r;

  1434. }

  1435. 

  1436. 

  1437. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  1439.    LGLW(_lglw);

  1440. 

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

  1442.    if(NULL != lglw)

  1443.    {

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

  1445.       {

  1446.          if(NULL != _retX)

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

  1448. 

  1449.          if(NULL != _retY)

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

  1451.       }

  1452.    }

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

  1454. }

  1455. 

  1456. 

  1457. // ---------------------------------------------------------------------------- lglw_redraw

  1458. void lglw_redraw(lglw_t _lglw) {

  1459.    LGLW(_lglw);

  1460. 

  1461.    if(NULL != lglw)

  1462.    {

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

  1464.       {

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

  1466.          XEvent xev;

  1467.          xev.xany.type       = Expose;

  1468.          xev.xany.serial     = 0;

  1469.          xev.xany.send_event = True;

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

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

  1472.          xev.xexpose.x      = 0;

  1473.          xev.xexpose.y      = 0;

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

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

  1476.          xev.xexpose.count  = 0;

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

  1478.                     True/*propagate*/,

  1479.                     ExposureMask/*event_mask*/,

  1480.                     &xev

  1481.                     );

  1482.          XFlush(lglw->xdsp);

  1483.       }

  1484.    }

  1485. }

  1486. 

  1487. 

  1488. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  1490.    LGLW(_lglw);

  1491. 

  1492.    if(NULL != lglw)

  1493.    {

  1494.       lglw->redraw.cbk = _cbk;

  1495.    }

  1496. }

  1497. 

  1498. 

  1499. // ---------------------------------------------------------------------------- lglw_glcontext_push

  1500. void lglw_glcontext_push(lglw_t _lglw) {

  1501.    LGLW(_lglw);

  1502. 

  1503.    if(NULL != lglw)

  1504.    {

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

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

  1507. 

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

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

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

  1511.       {

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

  1513.       }

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

  1515.    }

  1516. }

  1517. 

  1518. 

  1519. // ---------------------------------------------------------------------------- lglw_glcontext_rebind

  1520. void lglw_glcontext_rebind(lglw_t _lglw) {

  1521.    LGLW(_lglw);

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

  1523. 

  1524.    if(NULL != lglw)

  1525.    {

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

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

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

  1529.       {

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

  1531.       }

  1532.    }

  1533. }

  1534. 

  1535. 

  1536. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  1537. void lglw_glcontext_pop(lglw_t _lglw) {

  1538.    LGLW(_lglw);

  1539. 

  1540.    if(NULL != lglw)

  1541.    {

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

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

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

  1545.       {

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

  1547.       }

  1548.    }

  1549. }

  1550. 

  1551. 

  1552. // ---------------------------------------------------------------------------- lglw_swap_buffers

  1553. void lglw_swap_buffers(lglw_t _lglw) {

  1554.    LGLW(_lglw);

  1555. 

  1556.    if(NULL != lglw)

  1557.    {

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

  1559.       {

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

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

  1562.       }

  1563.    }

  1564. }

  1565. 

  1566. 

  1567. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  1570.    LGLW(_lglw);

  1571. 

  1572.    if(NULL != lglw)

  1573.    {

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

  1575.       {

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

  1577.          PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  1579.          if(NULL != glXSwapIntervalEXT)

  1580.          {

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

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

  1583.             lglw->win.swap_interval = _ival;

  1584.          }

  1585.       }

  1586.    }

  1587. }

  1588. 

  1589. 

  1590. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  1591. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  1592.    LGLW(_lglw);

  1593.    int32_t r = 0;

  1594. 

  1595.    if(NULL != lglw)

  1596.    {

  1597.       r = lglw->win.swap_interval;

  1598.    }

  1599. 

  1600.    return r;

  1601. }

  1602. 

  1603. 

  1604. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  1605. static void loc_handle_mouseleave(lglw_int_t *lglw) {

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

  1607. 

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

  1609.    {

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

  1611.    }

  1612. 

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

  1614. }

  1615. 

  1616. 

  1617. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  1618. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  1619. 

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

  1621. 

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

  1623.    {

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

  1625.    }

  1626. 

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

  1628. }

  1629. 

  1630. 

  1631. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  1633.    if(_bPressed)

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

  1635.    else

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

  1637. 

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

  1639.    {

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

  1641.    }

  1642. }

  1643. 

  1644. 

  1645. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  1646. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  1647. 

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

  1649.    {

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

  1651.    }

  1652. }

  1653. 

  1654. 

  1655. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1657.    LGLW(_lglw);

  1658. 

  1659.    if(NULL != lglw)

  1660.    {

  1661.       lglw->mouse.cbk = _cbk;

  1662.    }

  1663. }

  1664. 

  1665. 

  1666. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1668.    LGLW(_lglw);

  1669. 

  1670.    if(NULL != lglw)

  1671.    {

  1672.       lglw->focus.cbk = _cbk;

  1673.    }

  1674. }

  1675. 

  1676. 

  1677. // ---------------------------------------------------------------------------- loc_handle_key

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

  1679.    lglw_bool_t r = LGLW_FALSE;

  1680. 

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

  1682.    {

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

  1684.    }

  1685. 

  1686.    return r;

  1687. }

  1688. 

  1689. 

  1690. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  1692.    LGLW(_lglw);

  1693. 

  1694.    if(NULL != lglw)

  1695.    {

  1696.       lglw->keyboard.cbk = _cbk;

  1697.    }

  1698. }

  1699. 

  1700. 

  1701. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  1702. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  1703.    uint32_t r = 0u;

  1704.    LGLW(_lglw);

  1705. 

  1706.    if(NULL != lglw)

  1707.    {

  1708.       r = lglw->keyboard.kmod_state;

  1709.    }

  1710. 

  1711.    return r;

  1712. }

  1713. 

  1714. 

  1715. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  1717.    LGLW(_lglw);

  1718. 

  1719.    // (todo) implement me

  1720. 

  1721.    if(NULL != lglw)

  1722.    {

  1723.    }

  1724. }

  1725. 

  1726. 

  1727. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  1728. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  1729.    uint32_t r = 0u;

  1730.    LGLW(_lglw);

  1731. 

  1732.    if(NULL != lglw)

  1733.    {

  1734.       r = lglw->mouse.button_state;

  1735.    }

  1736. 

  1737.    return r;

  1738. }

  1739. 

  1740. 

  1741. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  1743.    LGLW(_lglw);

  1744. 

  1745.    if(NULL != lglw)

  1746.    {

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

  1748.       {

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

  1750.          {

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

  1752.             {

  1753.                lglw_mouse_ungrab(_lglw);

  1754.             }

  1755. 

  1756.             int result;

  1757. 

  1758.             switch(_grabMode)

  1759.             {

  1760.                default:

  1761.                case LGLW_MOUSE_GRAB_NONE:

  1762.                   break;

  1763. 

  1764.                case LGLW_MOUSE_GRAB_CAPTURE:

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

  1766.                                         True/*owner_events*/,

  1767.                                         NoEventMask/*event_mask*/,

  1768.                                         GrabModeAsync/*pointer_mode*/,

  1769.                                         GrabModeAsync/*keyboard_mode*/,

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

  1771.                                         None/*cursor*/,

  1772.                                         CurrentTime/*time*/);

  1773.                   if(GrabSuccess != result)

  1774.                   {

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

  1776.                   }

  1777.                   else

  1778.                   {

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

  1780.                   }

  1781.                   break;

  1782. 

  1783.                case LGLW_MOUSE_GRAB_WARP:

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

  1785.                                         True/*owner_events*/,

  1786.                                         NoEventMask/*event_mask*/,

  1787.                                         GrabModeAsync/*pointer_mode*/,

  1788.                                         GrabModeAsync/*keyboard_mode*/,

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

  1790.                                         None/*cursor*/,

  1791.                                         CurrentTime/*time*/);

  1792.                   if(GrabSuccess != result)

  1793.                   {

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

  1795.                   }

  1796.                   else

  1797.                   {

  1798.                      lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  1802.                   }

  1803.                   break;

  1804.             }

  1805.          }

  1806.       }

  1807.    }

  1808. }

  1809. 

  1810. 

  1811. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  1812. void lglw_mouse_ungrab(lglw_t _lglw) {

  1813.    LGLW(_lglw);

  1814. 

  1815.    if(NULL != lglw)

  1816.    {

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

  1818.       {

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

  1820.          {

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

  1822.             {

  1823.                default:

  1824.                case LGLW_MOUSE_GRAB_NONE:

  1825.                   break;

  1826. 

  1827.                case LGLW_MOUSE_GRAB_CAPTURE:

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

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

  1830.                   break;

  1831. 

  1832.                case LGLW_MOUSE_GRAB_WARP:

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

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

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

  1836.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1837.                   break;

  1838.             }

  1839.          }

  1840.       }

  1841.    }

  1842. }

  1843. 

  1844. 

  1845. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1847.    LGLW(_lglw);

  1848. 

  1849.    if(NULL != lglw)

  1850.    {

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

  1852.       {

  1853.          XWarpPointer(lglw->xdsp,

  1854.                       None/*src_w*/,

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

  1856.                       0/*src_x*/,

  1857.                       0/*src_y*/,

  1858.                       0/*src_width*/,

  1859.                       0/*src_height*/,

  1860.                       _x/*dest_x*/,

  1861.                       _y/*dest_y*/);

  1862.       }

  1863.    }

  1864. }

  1865. 

  1866. 

  1867. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1868. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1870.    {

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

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

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

  1874.    }

  1875. }

  1876. 

  1877. 

  1878. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1880.    LGLW(_lglw);

  1881. 

  1882.    if(NULL != lglw)

  1883.    {

  1884.       if(LGLW_FALSE == _bShow)

  1885.       {

  1886.          Pixmap noPxm;

  1887.          Cursor noCursor;

  1888.          XColor black, dummy;

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

  1890. 

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

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

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

  1894. 

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

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

  1897.          if(noPxm != None)

  1898.          {

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

  1900.          }

  1901.       }

  1902.       else

  1903.       {

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

  1905.       }

  1906.    }

  1907. }

  1908. 

  1909. 

  1910. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1912.    LGLW(_lglw);

  1913. 

  1914.    if(NULL != lglw)

  1915.    {

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

  1917.       lglw->timer.interval_ms = _millisec;

  1918.       lglw->timer.b_running   = LGLW_TRUE;

  1919.    }

  1920. }

  1921. 

  1922. 

  1923. // ---------------------------------------------------------------------------- lglw_timer_stop

  1924. void lglw_timer_stop(lglw_t _lglw) {

  1925.    LGLW(_lglw);

  1926. 

  1927.    if(NULL != lglw)

  1928.    {

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

  1930.       lglw->timer.b_running = LGLW_FALSE;

  1931.    }

  1932. }

  1933. 

  1934. 

  1935. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1937.    LGLW(_lglw);

  1938. 

  1939.    if(NULL != lglw)

  1940.    {

  1941.       lglw->timer.cbk = _cbk;

  1942.    }

  1943. }

  1944. 

  1945. 

  1946. // ---------------------------------------------------------------------------- loc_process_timer()

  1947. static void loc_process_timer(lglw_int_t *lglw) {

  1948.    if(lglw->timer.b_running)

  1949.    {

  1950.       uint32_t ms = loc_millisec_delta(lglw);

  1951. 

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

  1953.       {

  1954.          lglw->timer.last_ms = ms;

  1955. 

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

  1957.          {

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

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

  1960.          }

  1961.       }

  1962.    }

  1963. }

  1964. 

  1965. 

  1966. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1968. 

  1969.    // (todo) implement me

  1970. }

  1971. 

  1972. 

  1973. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1975.    LGLW(_lglw);

  1976. 

  1977.    if(NULL != _lglw)

  1978.    {

  1979.       lglw->dropfiles.cbk = _cbk;

  1980. 

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

  1982.    }

  1983. }

  1984. 

  1985. 

  1986. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1988.    LGLW(_lglw);

  1989. 

  1990.    if(NULL != _lglw)

  1991.    {

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

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

  1994.    }

  1995. }

  1996. 

  1997. 

  1998. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1999. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  2000.    lglw_bool_t r = LGLW_FALSE;

  2001.    LGLW(_lglw);

  2002. 

  2003.    if(NULL != _lglw)

  2004.    {

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

  2006.    }

  2007. 

  2008.    return r;

  2009. }

  2010. 

  2011. 

  2012. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  2014.    LGLW(_lglw);

  2015.    (void)_numChars;

  2016. 

  2017.    if(NULL != _text)

  2018.    {

  2019.       if(NULL != _lglw)

  2020.       {

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

  2022.          {

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

  2024. 

  2025.             if(numChars > 0u)

  2026.             {

  2027.                lglw->clipboard.numChars = numChars;

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

  2029. 

  2030.                uint32_t i;

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

  2032.                {

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

  2034.                }

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

  2036. 

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

  2038. 

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

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

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

  2042.             }

  2043.          }

  2044.       }

  2045.    }

  2046. }

  2047. 

  2048. 

  2049. // ---------------------------------------------------------------------------- loc_is_clipboard_event

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

  2051.    return _xevent->type == SelectionNotify;

  2052. }

  2053. 

  2054. 

  2055. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  2057.    LGLW(_lglw);

  2058. 

  2059.    if(NULL != _retNumChars)

  2060.       *_retNumChars = 0u;

  2061. 

  2062.    if(NULL != _retText)

  2063.       *_retText = 0;

  2064. 

  2065.    if(_maxChars > 0u)

  2066.    {

  2067.       if(NULL != _lglw)

  2068.       {

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

  2070.          {

  2071.             Window owner;

  2072.             XEvent xev;

  2073.             XSelectionEvent *cbReq;

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

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

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

  2077. 

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

  2079.             if(owner == None)

  2080.             {

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

  2082.                return;

  2083.             }

  2084. 

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

  2086.             {

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

  2088. 

  2089.                uint32_t i = 0u;

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

  2091.                {

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

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

  2094.                      break;

  2095.                }

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

  2097. 

  2098.                if(NULL != _retNumChars)

  2099.                   *_retNumChars = i;

  2100. 

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

  2102.                return;

  2103.             }

  2104. 

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

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

  2107. 

  2108.             cbReq = (XSelectionEvent*)&xev;

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

  2110.             {

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

  2112.                return;

  2113.             }

  2114. 

  2115.             Atom returnType;

  2116.             int returnFormat;

  2117.             unsigned long size, returnSize, bytesLeft;

  2118.             unsigned char *propertyValue = NULL;

  2119. 

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

  2121.                                0/*offset*/,

  2122.                                0/*length*/,

  2123.                                False/*delete*/,

  2124.                                AnyPropertyType/*req_type*/,

  2125.                                &returnType/*actual_type_return*/,

  2126.                                &returnFormat/*actual_format_return*/,

  2127.                                &returnSize/*nitems_return*/,

  2128.                                &size/*bytes_after_return*/,

  2129.                                &propertyValue/*prop_return*/);

  2130.             XFree(propertyValue);

  2131. 

  2132.             if(utf8 != returnType)

  2133.             {

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

  2135.                return;

  2136.             }

  2137. 

  2138.             if(8u != returnFormat)

  2139.             {

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

  2141.                return;

  2142.             }

  2143. 

  2144.             if(_maxChars < size)

  2145.                size = _maxChars;

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

  2147. 

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

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

  2150.                                0/*offset*/,

  2151.                                size/*length*/,

  2152.                                True/*delete*/,

  2153.                                AnyPropertyType/*req_type*/,

  2154.                                &returnType/*actual_type_return*/,

  2155.                                &returnFormat/*actual_format_return*/,

  2156.                                &returnSize/*nitems_return*/,

  2157.                                &bytesLeft/*bytes_after_return*/,

  2158.                                &propertyValue/*prop_return*/);

  2159. 

  2160.             if(returnSize == 0)

  2161.             {

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

  2163.                return;

  2164.             }

  2165. 

  2166.             uint32_t i = 0u;

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

  2168.             {

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

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

  2171.                   break;

  2172.             }

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

  2174. 

  2175.             if(NULL != _retNumChars)

  2176.                *_retNumChars = i;

  2177. 

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

  2179.             XFree(propertyValue);

  2180.          }

  2181.       }

  2182.    }

  2183. }

  2184. 

  2185. 

  2186. // ---------------------------------------------------------------------------- lglw_events

  2187. void lglw_events(lglw_t _lglw) {

  2188.    LGLW(_lglw);

  2189. 

  2190.    if(NULL != lglw)

  2191.    {

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

  2193.       {

  2194.          XEvent xev;

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

  2196.          if(queued > 0)

  2197.          {

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

  2199.          }

  2200.          while(queued)

  2201.          {

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

  2203.             loc_eventProc(&xev, lglw);

  2204.             queued--;

  2205.          }

  2206. 

  2207.          loc_process_timer(lglw);

  2208.       }

  2209.    }

  2210. }