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

2157 lines
69KB
Raw Blame History 

  1. /* ----

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

  3.  * ---- author : bsp

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

  5.  * ----

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

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

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

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

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

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

  12.  * ----

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

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

  15.  * ----

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

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

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

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

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

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

  22.  * ---- THE SOFTWARE.

  23.  * ----

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

  25.  * ----

  26.  * ---- created: 04Aug2018

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

  28.  * ----

  29.  * ----

  30.  */

  31. 

  32. #include "lglw.h"

  33. 

  34. #include <stdlib.h>

  35. #include <stdio.h>

  36. #include <string.h>

  37. 

  38. #include <X11/Xlib.h>

  39. #include <X11/Xutil.h>

  40. #include <X11/Xos.h>

  41. #include <X11/Xatom.h>

  42. 

  43. #include <GL/gl.h>

  44. #include <GL/glx.h>

  45. 

  46. #ifdef ARCH_X64

  47. #include <sys/mman.h>

  48. #include <unistd.h>

  49. #endif // ARCH_X64

  50. 

  51. //

  52. // Regular log entry (low frequency)

  53. //

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

  55. #define Dlog if(0);else printf

  56. 

  57. //

  58. // Verbose log entry

  59. //

  60. // #define Dlog_v if(1);else printf

  61. #define Dlog_v if(0);else printf

  62. 

  63. //

  64. // Very-verbose log entry

  65. //

  66. // #define Dlog_vv if(1);else printf

  67. #define Dlog_vv if(0);else printf

  68. 

  69. //

  70. // Very-very-verbose log entry

  71. //

  72. #define Dlog_vvv if(1);else printf

  73. // #define Dlog_vvv if(0);else printf

  74. 

  75. //

  76. // Print to stdout

  77. //

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

  79. //

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

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

  82. 

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

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

  85. 

  86. // ---------------------------------------------------------------------------- macros and defines

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

  88. 

  89. #define LGLW_DEFAULT_HIDDEN_W  (800)

  90. #define LGLW_DEFAULT_HIDDEN_H  (600)

  91. 

  92. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  93. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  94. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  95. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  96. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  97. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  98. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  99. 

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

  101. 

  102. 

  103. // ---------------------------------------------------------------------------- structs and typedefs

  104. typedef struct lglw_int_s {

  105.    void        *user_data;    // arbitrary user data

  106.    Display     *xdsp;

  107.    XVisualInfo *vi;

  108.    Colormap     cmap;

  109.    Window       parent_xwnd;  // created by host

  110. 

  111.    struct {

  112.       lglw_vec2i_t size;

  113.       Window       xwnd;

  114.    } hidden;

  115. 

  116.    struct {

  117.       lglw_vec2i_t size;

  118.       Window       xwnd;

  119.       lglw_bool_t  mapped;

  120.       int32_t      swap_interval;

  121.       lglw_bool_t  b_owner;

  122.    } win;

  123. 

  124.    GLXContext   ctx;

  125. 

  126.    struct {

  127.       GLXContext   ctx;

  128.       GLXDrawable  drw;

  129.    } prev;

  130. 

  131.    struct {

  132.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  133.       lglw_keyboard_fxn_t cbk;

  134.    } keyboard;

  135. 

  136.    struct {

  137.       lglw_vec2i_t     p;  // last seen mouse position

  138.       uint32_t         button_state;

  139.       lglw_mouse_fxn_t cbk;

  140.       struct {

  141.          uint32_t         mode;

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

  143.          lglw_bool_t      b_queue_warp;

  144.          lglw_vec2i_t     last_p;

  145.       } grab;

  146.       struct {

  147.          lglw_bool_t      b_enable;

  148.          lglw_bool_t      b_update_queued;

  149.          lglw_bool_t      b_syn_rmb;

  150.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  151.          uint32_t         hold_start_ms;

  152.          lglw_vec2i_t     hold_start_p;

  153.       } touch;

  154.    } mouse;

  155. 

  156.    struct {

  157.       uint32_t         state;

  158.       lglw_focus_fxn_t cbk;

  159.    } focus;

  160. 

  161.    struct {

  162.       lglw_bool_t      b_running;

  163.       lglw_timer_fxn_t cbk;

  164.       struct timeval   tv_start;

  165.       uint32_t         interval_ms;

  166.       uint32_t         last_ms;

  167.    } timer;

  168. 

  169.    struct {

  170.       uint32_t numChars;

  171.       char *data;

  172.    } clipboard;

  173. 

  174.    struct {

  175.       lglw_dropfiles_fxn_t cbk;

  176.    } dropfiles;

  177. 

  178.    struct {

  179.       lglw_redraw_fxn_t cbk;

  180.    } redraw;

  181. 

  182. } lglw_int_t;

  183. 

  184. 

  185. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  187. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  188. 

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

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

  191. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  192. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  193. 

  194. static void loc_handle_mouseleave (lglw_int_t *lglw);

  195. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  197. static void loc_handle_mousemotion (lglw_int_t *lglw);

  198. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  199. 

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

  201. 

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

  203. static void loc_XEventProc (void *_xevent);

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

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

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

  207. 

  208. static void loc_millisec_init (lglw_int_t *lglw);

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

  210. static void loc_process_timer (lglw_int_t *lglw);

  211. 

  212. 

  213. // ---------------------------------------------------------------------------- lglw_millisec_init

  214. static void loc_millisec_init (lglw_int_t *lglw) {

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

  216. }

  217. 

  218. // ---------------------------------------------------------------------------- lglw_millisec_delta

  219. static uint32_t loc_millisec_delta (lglw_int_t *lglw) {

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

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

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

  223. }

  224. 

  225. 

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

  227. // ---------------------------------------------------------------------------- lglw_log

  228. static FILE *logfile;

  229. 

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

  231.    fprintf(logfile, logData);

  232.    fflush(logfile);

  233.    printf(logData);

  234. }

  235. 

  236. 

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

  238. // ---------------------------------------------------------------------------- xerror_log

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

  240.    char error_text[1024];

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

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

  243.    return 0;

  244. }

  245. 

  246. 

  247. // ---------------------------------------------------------------------------- lglw_init

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

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

  250. 

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

  252. 

  253.    // TODO: remove/improve

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

  255.    XSetErrorHandler(xerror_handler);

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

  257. 

  258.    loc_millisec_init(lglw);

  259. 

  260.    if(NULL != lglw)

  261.    {

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

  263. 

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

  265.       if(_w <= 16)

  266.          _w = LGLW_DEFAULT_HIDDEN_W;

  267. 

  268.       if(_h <= 16)

  269.          _h = LGLW_DEFAULT_HIDDEN_H;

  270. 

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

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

  273.       {

  274.          free(lglw);

  275.          lglw = NULL;

  276.       }

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

  278.    }

  279. 

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

  281. 

  282.    return lglw;

  283. }

  284. 

  285. 

  286. // ---------------------------------------------------------------------------- lglw_exit

  287. void lglw_exit(lglw_t _lglw) {

  288.    LGLW(_lglw);

  289. 

  290.    if(NULL != lglw)

  291.    {

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

  293. 

  294.       loc_destroy_hidden_window(lglw);

  295. 

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

  297. 

  298.       fclose(logfile);

  299.       free(lglw);

  300.    }

  301. }

  302. 

  303. 

  304. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  306.    LGLW(_lglw);

  307. 

  308.    if(NULL != lglw)

  309.    {

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

  311.       lglw->user_data = _userData;

  312.    }

  313. }

  314. 

  315. // ---------------------------------------------------------------------------- lglw_userdata_get

  316. void *lglw_userdata_get(lglw_t _lglw) {

  317.    LGLW(_lglw);

  318. 

  319.    if(NULL != lglw)

  320.    {

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

  322.       return lglw->user_data;

  323.    }

  324. 

  325.    return NULL;

  326. }

  327. 

  328. 

  329. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  331. 

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

  333. 

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

  335.    XSetWindowAttributes swa;

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

  337.    int screen;

  338. 

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

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

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

  342. 

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

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

  345. 

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

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

  348.    {

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

  350.       return LGLW_FALSE;

  351.    }

  352. 

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

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

  355. 

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

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

  358.    {

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

  360.       return LGLW_FALSE;

  361.    }

  362. 

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

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

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

  366. 

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

  368.    swa.border_pixel = 0;

  369.    swa.colormap = lglw->cmap;

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

  371.                                      0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  373. 

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

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

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

  377. 

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

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

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

  381. 

  382.    return LGLW_TRUE;

  383. }

  384. 

  385. 

  386. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  387. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  390.    {

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

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

  393.    }

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

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

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

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

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

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

  400. 

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

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

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

  404. }

  405. 

  406. 

  407. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  414. 

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

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

  417. 

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

  419. 

  420.    loc_process_timer(lglw);

  421. 

  422.    if(NULL != lglw)

  423.    {

  424.       lglw_bool_t eventHandled = LGLW_FALSE;

  425. 

  426.       switch(xev->type)

  427.       {

  428.          default:

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

  430.             eventHandled = LGLW_FALSE;

  431.             break;

  432. 

  433.          case Expose:

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

  435.             loc_handle_queued_mouse_warp(lglw);

  436.             eventHandled = LGLW_FALSE;

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

  438.             {

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

  440.                eventHandled = LGLW_TRUE;

  441.             }

  442.             break;

  443. 

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

  445. 

  446.          case FocusIn:

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

  448.             eventHandled = LGLW_FALSE;

  449.             break;

  450. 

  451.          case FocusOut:

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

  453.             eventHandled = LGLW_FALSE;

  454.             break;

  455. 

  456.          case EnterNotify:

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

  458.             ; // empty statement

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

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

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

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

  463.             loc_handle_mousemotion(lglw);

  464. 

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

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

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

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

  469.             {

  470.                loc_handle_mouseenter(lglw);

  471.             }

  472.             eventHandled = LGLW_TRUE;

  473. 

  474.             break;

  475. 

  476.          case LeaveNotify:

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

  478.             ; // empty statement

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

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

  481. 

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

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

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

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

  486.             {

  487.                loc_handle_mouseleave(lglw);

  488.             }

  489.             eventHandled = LGLW_TRUE;

  490. 

  491.             break;

  492. 

  493.          case MotionNotify:

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

  495.             ; // empty statement

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

  497. 

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

  499.             {

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

  501. 

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

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

  504. 

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

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

  507.             }

  508.             else

  509.             {

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

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

  512.             }

  513. 

  514.             loc_handle_mousemotion(lglw);

  515.             eventHandled = LGLW_TRUE;

  516. 

  517.             break;

  518. 

  519.          case KeyPress:

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

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

  522. 

  523.             eventHandled = LGLW_FALSE;

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

  525.             switch(xkp)

  526.             {

  527.                default:

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

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

  530.                   {

  531.                      KeySym xkpl;

  532.                      KeySym xkpu;

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

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

  535.                   }

  536.                   else

  537.                   {

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

  539.                   }

  540.                   break;

  541. 

  542.                case NoSymbol:

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

  544.                   break;

  545. 

  546.                case XK_Left:

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

  548.                   break;

  549. 

  550.                case XK_Right:

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

  552.                   break;

  553. 

  554.                case XK_Up:

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

  556.                   break;

  557. 

  558.                case XK_Down:

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

  560.                   break;

  561. 

  562.                case XK_Insert:

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

  564.                   break;

  565. 

  566.                case XK_Delete:

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

  568.                   break;

  569. 

  570.                case XK_Home:

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

  572.                   break;

  573. 

  574.                case XK_End:

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

  576.                   break;

  577. 

  578.                case XK_Prior:

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

  580.                   break;

  581. 

  582.                case XK_Next:

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

  584.                   break;

  585. 

  586.                case XK_F1:

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

  588.                   break;

  589. 

  590.                case XK_F2:

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

  592.                   break;

  593. 

  594.                case XK_F3:

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

  596.                   break;

  597. 

  598.                case XK_F4:

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

  600.                   break;

  601. 

  602.                case XK_F5:

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

  604.                   break;

  605. 

  606.                case XK_F6:

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

  608.                   break;

  609. 

  610.                case XK_F7:

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

  612.                   break;

  613. 

  614.                case XK_F8:

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

  616.                   break;

  617. 

  618.                case XK_F9:

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

  620.                   break;

  621. 

  622.                case XK_F10:

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

  624.                   break;

  625. 

  626.                case XK_F11:

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

  628.                   break;

  629. 

  630.                case XK_F12:

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

  632.                   break;

  633. 

  634.                case XK_BackSpace:

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

  636.                   break;

  637. 

  638.                case XK_Tab:

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

  640.                   break;

  641. 

  642.                case XK_Return:

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

  644.                   break;

  645. 

  646.                case XK_Escape:

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

  648.                   break;

  649. 

  650.                case XK_Shift_L:

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

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

  653.                   eventHandled = LGLW_FALSE;

  654.                   break;

  655. 

  656.                case XK_Shift_R:

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

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

  659.                   eventHandled = LGLW_FALSE;

  660.                   break;

  661. 

  662.                case XK_Control_L:

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

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

  665.                   eventHandled = LGLW_FALSE;

  666.                   break;

  667. 

  668.                case XK_Control_R:

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

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

  671.                   eventHandled = LGLW_FALSE;

  672.                   break;

  673.             }

  674. 

  675.             break;

  676. 

  677.          case KeyRelease:

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

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

  680. 

  681.             eventHandled = LGLW_FALSE;

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

  683.             switch(xkr)

  684.             {

  685.                default:

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

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

  688.                   {

  689.                      KeySym xkrl;

  690.                      KeySym xkru;

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

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

  693.                   }

  694.                   else

  695.                   {

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

  697.                   }

  698.                   break;

  699. 

  700.                case NoSymbol:

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

  702.                   break;

  703. 

  704.                case XK_Left:

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

  706.                   break;

  707. 

  708.                case XK_Right:

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

  710.                   break;

  711. 

  712.                case XK_Up:

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

  714.                   break;

  715. 

  716.                case XK_Down:

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

  718.                   break;

  719. 

  720.                case XK_Insert:

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

  722.                   break;

  723. 

  724.                case XK_Delete:

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

  726.                   break;

  727. 

  728.                case XK_Home:

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

  730.                   break;

  731. 

  732.                case XK_End:

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

  734.                   break;

  735. 

  736.                case XK_Prior:

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

  738.                   break;

  739. 

  740.                case XK_Next:

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

  742.                   break;

  743. 

  744.                case XK_F1:

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

  746.                   break;

  747. 

  748.                case XK_F2:

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

  750.                   break;

  751. 

  752.                case XK_F3:

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

  754.                   break;

  755. 

  756.                case XK_F4:

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

  758.                   break;

  759. 

  760.                case XK_F5:

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

  762.                   break;

  763. 

  764.                case XK_F6:

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

  766.                   break;

  767. 

  768.                case XK_F7:

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

  770.                   break;

  771. 

  772.                case XK_F8:

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

  774.                   break;

  775. 

  776.                case XK_F9:

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

  778.                   break;

  779. 

  780.                case XK_F10:

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

  782.                   break;

  783. 

  784.                case XK_F11:

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

  786.                   break;

  787. 

  788.                case XK_F12:

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

  790.                   break;

  791. 

  792.                case XK_BackSpace:

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

  794.                   break;

  795. 

  796.                case XK_Tab:

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

  798.                   break;

  799. 

  800.                case XK_Return:

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

  802.                   break;

  803. 

  804.                case XK_Escape:

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

  806.                   break;

  807. 

  808.                case XK_Shift_L:

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

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

  811.                   eventHandled = LGLW_FALSE;

  812.                   break;

  813. 

  814.                case XK_Shift_R:

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

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

  817.                   eventHandled = LGLW_FALSE;

  818.                   break;

  819. 

  820.                case XK_Control_L:

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

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

  823.                   eventHandled = LGLW_FALSE;

  824.                   break;

  825. 

  826.                case XK_Control_R:

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

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

  829.                   eventHandled = LGLW_FALSE;

  830.                   break;

  831.             }

  832. 

  833.             break;

  834. 

  835.          case ButtonPress:

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

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

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

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

  840. 

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

  842.             {

  843.                loc_handle_mouseenter(lglw);

  844.             }

  845. 

  846.             switch(btnPress->button)

  847.             {

  848.                default:

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

  850.                   eventHandled = LGLW_FALSE;

  851.                   break;

  852.                case Button1:

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

  854.                   eventHandled = LGLW_TRUE;

  855.                   break;

  856.                case Button2:

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

  858.                   eventHandled = LGLW_TRUE;

  859.                   break;

  860.                case Button3:

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

  862.                   eventHandled = LGLW_TRUE;

  863.                   break;

  864.                case Button4:

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

  866.                   eventHandled = LGLW_TRUE;

  867.                   break;

  868.                case Button5:

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

  870.                   eventHandled = LGLW_TRUE;

  871.                   break;

  872.             }

  873.             break;

  874. 

  875.          case ButtonRelease:

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

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

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

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

  880.             switch(btnRelease->button)

  881.             {

  882.                default:

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

  884.                   eventHandled = LGLW_FALSE;

  885.                   break;

  886.                case Button1:

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

  888.                   eventHandled = LGLW_TRUE;

  889.                   break;

  890.                case Button2:

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

  892.                   eventHandled = LGLW_TRUE;

  893.                   break;

  894.                case Button3:

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

  896.                   eventHandled = LGLW_TRUE;

  897.                   break;

  898.                case Button4:

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

  900.                   eventHandled = LGLW_TRUE;

  901.                   break;

  902.                case Button5:

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

  904.                   eventHandled = LGLW_TRUE;

  905.                   break;

  906.             }

  907.             break;

  908. 

  909.          case SelectionClear:

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

  911.             lglw->clipboard.numChars = 0;

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

  913.             eventHandled = LGLW_TRUE;

  914.             break;

  915. 

  916.          case SelectionRequest:

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

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

  919.             XSelectionEvent cbRes;

  920. 

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

  922. 

  923.             cbRes.type = SelectionNotify;

  924.             cbRes.requestor = cbReq->requestor;

  925.             cbRes.selection = cbReq->selection;

  926.             cbRes.target = cbReq->target;

  927.             cbRes.time = cbReq->time;

  928. 

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

  930.             {

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

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

  933. 

  934.                cbRes.property = cbReq->property;

  935.             }

  936.             else

  937.             {

  938.                cbRes.property = None;

  939.             }

  940. 

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

  942.             eventHandled = LGLW_TRUE;

  943. 

  944.             break;

  945.       }

  946. 

  947.       if(LGLW_FALSE == eventHandled)

  948.       {

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

  950.          {

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

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

  953.          }

  954.          else

  955.          {

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

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

  958.          }

  959.       }

  960.    }

  961. }

  962. 

  963. static void loc_XEventProc(void *_xevent) {

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

  965. 

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

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

  968. 

  969.    if(NULL != xev)

  970.    {

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

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

  973. 

  974.       loc_eventProc(xev, lglw);

  975.    }

  976. 

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

  978. }

  979. 

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

  981.    size_t data = (size_t)_value;

  982.    long temp[2];

  983. 

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

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

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

  987. 

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

  989. 

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

  991. 

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

  993.    XChangeProperty(_display, _window,

  994.                    atom/*property*/,

  995.                    atom/*type*/,

  996.                    32/*format*/,

  997.                    PropModeReplace/*mode*/,

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

  999.                    2/*nelements*/

  1000.                    );

  1001. }

  1002. 

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

  1004.    int userSize;

  1005.    unsigned long bytes;

  1006.    unsigned long userCount;

  1007.    unsigned char *data;

  1008.    Atom userType;

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

  1010. 

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

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

  1013.    XGetWindowProperty(_display,

  1014.                       _window,

  1015.                       atom,

  1016.                       0/*offset*/,

  1017.                       1/*length*/,

  1018.                       False/*delete*/,

  1019.                       AnyPropertyType,

  1020.                       &userType/*actual_type_return*/,

  1021.                       &userSize/*actual_format_return*/,

  1022.                       &userCount/*nitems_return*/,

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

  1024.                       &data);

  1025. 

  1026.    union {

  1027.       uint32_t ui[2];

  1028.       void *any;

  1029.    } uptr;

  1030.    uptr.any = 0;

  1031. 

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

  1033. 

  1034.    if(NULL != data)

  1035.    {

  1036.       if(userCount >= 1)

  1037.       {

  1038.          // lower 32-bit

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

  1040.          uptr.ui[1] = 0;

  1041. 

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

  1043. 

  1044.          XFree(data);

  1045. 

  1046.          XGetWindowProperty(_display,

  1047.                             _window,

  1048.                             atom,

  1049.                             1/*offset*/,

  1050.                             1/*length*/,

  1051.                             False/*delete*/,

  1052.                             AnyPropertyType,

  1053.                             &userType/*actual_type_return*/,

  1054.                             &userSize/*actual_format_return*/,

  1055.                             &userCount/*nitems_return*/,

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

  1057.                             &data);

  1058. 

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

  1060.          if(NULL != data)

  1061.          {

  1062.             // upper 32-bit

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

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

  1065.             XFree(data);

  1066.          }

  1067.       }

  1068.    }

  1069. 

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

  1071. 

  1072.    return uptr.any;

  1073. }

  1074. 

  1075. 

  1076. #ifdef ARCH_X64

  1077. #if 0

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

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

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

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

  1082.    size_t data = (size_t)loc_eventProc;

  1083.    long temp[2];

  1084. 

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

  1086. 

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

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

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

  1090. 

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

  1092.    XChangeProperty(display, window,

  1093.                    atom/*property*/,

  1094.                    atom/*type*/,

  1095.                    32/*format*/,

  1096.                    PropModeReplace/*mode*/,

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

  1098.                    2/*nelements*/

  1099.                    );

  1100. }

  1101. #else

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

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

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

  1105.    //

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

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

  1108.    //

  1109. 

  1110.    // based on mach_override

  1111.    static const unsigned char kJumpInstructions[] = {

  1112.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  1113.          0x00, 0x00, 0x00, 0x00,

  1114.          0x00, 0x00, 0x00, 0x00

  1115.    };

  1116.    static const int kJumpAddress = 6;

  1117. 

  1118.    static char *ptr = 0;

  1119.    if (!ptr) {

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

  1121.                          getpagesize()/*PAGE_SIZE*/,

  1122.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  1123.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  1124.                          0, 0);

  1125.       if (ptr == MAP_FAILED) {

  1126.          perror("mmap");

  1127.          ptr = 0;

  1128.          return;

  1129.       } else {

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

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

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

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

  1134.       }

  1135.    }

  1136. 

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

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

  1139.    XChangeProperty(display, window,

  1140.                    atom/*property*/,

  1141.                    atom/*type*/,

  1142.                    32/*format*/,

  1143.                    PropModeReplace/*mode*/,

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

  1145.                    2/*nelements*/

  1146.                    );

  1147. }

  1148. #endif

  1149. #else

  1150. // Pulled from the eXT2 example

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

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

  1153. 

  1154.    // (note) 32-bit only

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

  1156.    XChangeProperty(display, window,

  1157.                    atom/*property*/,

  1158.                    atom/*type*/,

  1159.                    32/*format*/,

  1160.                    PropModeReplace/*mode*/,

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

  1162.                    1/*nelements*/

  1163.                    );

  1164. }

  1165. #endif // ARCH_X64

  1166. 

  1167. 

  1168. // ---------------------------------------------------------------------------- lglw_window_open

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

  1170.    lglw_bool_t r = LGLW_FALSE;

  1171.    LGLW(_lglw);

  1172. 

  1173.    if(NULL != lglw)

  1174.    {

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

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

  1177. 

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

  1179.       if(_w <= 16)

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

  1181. 

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

  1183.       if(_h <= 16)

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

  1185. 

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

  1187. 

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

  1189.       XSetWindowAttributes swa;

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

  1191. 

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

  1193.       swa.border_pixel = 0;

  1194.       swa.colormap = lglw->cmap;

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

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

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

  1198.                                      0/*x*/,

  1199.                                      0/*y*/,

  1200.                                      _w/*width*/,

  1201.                                      _h/*height*/,

  1202.                                      0/*border_width*/,

  1203.                                      CopyFromParent/*depth*/,

  1204.                                      InputOutput/*class*/,

  1205.                                      lglw->vi->visual,

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

  1207.                                      &swa/*attributes*/

  1208.                                      );

  1209. 

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

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

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

  1213.                              "LGLW"/*window_name*/,

  1214.                              "LGLW"/*icon_name*/,

  1215.                              None/*icon_pixmap*/,

  1216.                              NULL/*argv*/,

  1217.                              0/*argc*/,

  1218.                              NULL/*XSizeHints*/

  1219.                              );

  1220. 

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

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

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

  1224. 

  1225.       if(0 != _parentHWNDOrNull)

  1226.       {

  1227.          // loc_setEventProc(lglw->xdsp, lglw->parent_xwnd);

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

  1229.       }

  1230. 

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

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

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

  1234.       if (0 != _parentHWNDOrNull)

  1235.       {

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

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

  1238.       }

  1239. 

  1240.       lglw->win.b_owner = LGLW_TRUE;

  1241. 

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

  1243.       if(lglw->win.b_owner)

  1244.       {

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

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

  1247.       }

  1248. 

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

  1250.       lglw->win.mapped = LGLW_TRUE;

  1251. 

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

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

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

  1255. 

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

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

  1258. 

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

  1260. 

  1261.       r = LGLW_TRUE;

  1262.    }

  1263.    return r;

  1264. }

  1265. 

  1266. 

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

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

  1269.    lglw_bool_t r = LGLW_FALSE;

  1270.    LGLW(_lglw);

  1271. 

  1272.    if(NULL != lglw)

  1273.    {

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

  1275.       {

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

  1277.          r = LGLW_TRUE;

  1278. 

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

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

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

  1282. 

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

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

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

  1286. 

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

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

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

  1290. 

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

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

  1293.          unsigned int num_children;

  1294. 

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

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

  1297.             return r;

  1298. 

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

  1300.          if(children)

  1301.             XFree((char *)children);

  1302. 

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

  1304.          // Resize parent window (if any)

  1305.          if(0 != parent)

  1306.          {

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

  1308.             int x, y;

  1309.             unsigned int width, height;

  1310.             unsigned int border_width;

  1311.             unsigned int depth;

  1312. 

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

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

  1315.                return r;

  1316. 

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

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

  1319.          }

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

  1321.       }

  1322.    }

  1323. 

  1324.    return r;

  1325. }

  1326. 

  1327. 

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

  1329. void lglw_window_close (lglw_t _lglw) {

  1330.    LGLW(_lglw);

  1331. 

  1332.    if(NULL != lglw)

  1333.    {

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

  1335.       {

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

  1337.          lglw_timer_stop(_lglw);

  1338. 

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

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

  1341. 

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

  1343.          if(lglw->win.b_owner)

  1344.          {

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

  1346.             lglw->win.b_owner = LGLW_FALSE;

  1347.          }

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

  1349.          lglw->win.xwnd = 0;

  1350.          lglw->win.mapped = LGLW_FALSE;

  1351.       }

  1352.    }

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

  1354. }

  1355. 

  1356. 

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

  1358. void lglw_window_show(lglw_t _lglw) {

  1359.    LGLW(_lglw);

  1360. 

  1361.    if(NULL != lglw)

  1362.    {

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

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

  1365. 

  1366.       lglw->win.mapped = LGLW_TRUE;

  1367.    }

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

  1369. }

  1370. 

  1371. 

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

  1373. void lglw_window_hide(lglw_t _lglw) {

  1374.    LGLW(_lglw);

  1375. 

  1376.    if(NULL != lglw)

  1377.    {

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

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

  1380. 

  1381.       lglw->win.mapped = LGLW_FALSE;

  1382.    }

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

  1384. }

  1385. 

  1386. 

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

  1388. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  1389.    lglw_bool_t r = LGLW_FALSE;

  1390.    LGLW(_lglw);

  1391. 

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

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

  1394.    {

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

  1396.       r = lglw->win.mapped;

  1397.    }

  1398. 

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

  1400.    return r;

  1401. }

  1402. 

  1403. 

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

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

  1406.    LGLW(_lglw);

  1407. 

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

  1409.    if(NULL != lglw)

  1410.    {

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

  1412.       {

  1413.          if(NULL != _retX)

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

  1415. 

  1416.          if(NULL != _retY)

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

  1418.       }

  1419.    }

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

  1421. }

  1422. 

  1423. 

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

  1425. void lglw_redraw(lglw_t _lglw) {

  1426.    LGLW(_lglw);

  1427. 

  1428.    if(NULL != lglw)

  1429.    {

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

  1431.       {

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

  1433.          XEvent xev;

  1434.          xev.xany.type       = Expose;

  1435.          xev.xany.serial     = 0;

  1436.          xev.xany.send_event = True;

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

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

  1439.          xev.xexpose.x      = 0;

  1440.          xev.xexpose.y      = 0;

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

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

  1443.          xev.xexpose.count  = 0;

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

  1445.                     True/*propagate*/,

  1446.                     ExposureMask/*event_mask*/,

  1447.                     &xev

  1448.                     );

  1449.          XFlush(lglw->xdsp);

  1450.       }

  1451.    }

  1452. }

  1453. 

  1454. 

  1455. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  1457.    LGLW(_lglw);

  1458. 

  1459.    if(NULL != lglw)

  1460.    {

  1461.       lglw->redraw.cbk = _cbk;

  1462.    }

  1463. }

  1464. 

  1465. 

  1466. // ---------------------------------------------------------------------------- lglw_glcontext_push

  1467. void lglw_glcontext_push(lglw_t _lglw) {

  1468.    LGLW(_lglw);

  1469. 

  1470.    if(NULL != lglw)

  1471.    {

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

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

  1474. 

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

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

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

  1478.       {

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

  1480.       }

  1481.    }

  1482. }

  1483. 

  1484. 

  1485. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  1486. void lglw_glcontext_pop(lglw_t _lglw) {

  1487.    LGLW(_lglw);

  1488. 

  1489.    if(NULL != lglw)

  1490.    {

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

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

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

  1494.       {

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

  1496.       }

  1497.    }

  1498. }

  1499. 

  1500. 

  1501. // ---------------------------------------------------------------------------- lglw_swap_buffers

  1502. void lglw_swap_buffers(lglw_t _lglw) {

  1503.    LGLW(_lglw);

  1504. 

  1505.    if(NULL != lglw)

  1506.    {

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

  1508.       {

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

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

  1511.       }

  1512.    }

  1513. }

  1514. 

  1515. 

  1516. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  1519.    LGLW(_lglw);

  1520. 

  1521.    if(NULL != lglw)

  1522.    {

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

  1524.       {

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

  1526.          PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  1528.          if(NULL != glXSwapIntervalEXT)

  1529.          {

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

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

  1532.             lglw->win.swap_interval = _ival;

  1533.          }

  1534.       }

  1535.    }

  1536. }

  1537. 

  1538. 

  1539. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  1540. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  1541.    LGLW(_lglw);

  1542.    int32_t r = 0;

  1543. 

  1544.    if(NULL != lglw)

  1545.    {

  1546.       r = lglw->win.swap_interval;

  1547.    }

  1548. 

  1549.    return r;

  1550. }

  1551. 

  1552. 

  1553. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  1554. static void loc_handle_mouseleave(lglw_int_t *lglw) {

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

  1556. 

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

  1558.    {

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

  1560.    }

  1561. 

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

  1563. }

  1564. 

  1565. 

  1566. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  1567. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  1568. 

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

  1570. 

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

  1572.    {

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

  1574.    }

  1575. 

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

  1577. }

  1578. 

  1579. 

  1580. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  1582.    if(_bPressed)

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

  1584.    else

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

  1586. 

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

  1588.    {

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

  1590.    }

  1591. }

  1592. 

  1593. 

  1594. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  1595. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  1596. 

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

  1598.    {

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

  1600.    }

  1601. }

  1602. 

  1603. 

  1604. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1606.    LGLW(_lglw);

  1607. 

  1608.    if(NULL != lglw)

  1609.    {

  1610.       lglw->mouse.cbk = _cbk;

  1611.    }

  1612. }

  1613. 

  1614. 

  1615. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  1617.    LGLW(_lglw);

  1618. 

  1619.    if(NULL != lglw)

  1620.    {

  1621.       lglw->focus.cbk = _cbk;

  1622.    }

  1623. }

  1624. 

  1625. 

  1626. // ---------------------------------------------------------------------------- loc_handle_key

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

  1628.    lglw_bool_t r = LGLW_FALSE;

  1629. 

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

  1631.    {

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

  1633.    }

  1634. 

  1635.    return r;

  1636. }

  1637. 

  1638. 

  1639. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  1641.    LGLW(_lglw);

  1642. 

  1643.    if(NULL != lglw)

  1644.    {

  1645.       lglw->keyboard.cbk = _cbk;

  1646.    }

  1647. }

  1648. 

  1649. 

  1650. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  1651. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  1652.    uint32_t r = 0u;

  1653.    LGLW(_lglw);

  1654. 

  1655.    if(NULL != lglw)

  1656.    {

  1657.       r = lglw->keyboard.kmod_state;

  1658.    }

  1659. 

  1660.    return r;

  1661. }

  1662. 

  1663. 

  1664. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  1666.    LGLW(_lglw);

  1667. 

  1668.    // (todo) implement me

  1669. 

  1670.    if(NULL != lglw)

  1671.    {

  1672.    }

  1673. }

  1674. 

  1675. 

  1676. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  1677. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  1678.    uint32_t r = 0u;

  1679.    LGLW(_lglw);

  1680. 

  1681.    if(NULL != lglw)

  1682.    {

  1683.       r = lglw->mouse.button_state;

  1684.    }

  1685. 

  1686.    return r;

  1687. }

  1688. 

  1689. 

  1690. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  1692.    LGLW(_lglw);

  1693. 

  1694.    if(NULL != lglw)

  1695.    {

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

  1697.       {

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

  1699.          {

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

  1701.             {

  1702.                lglw_mouse_ungrab(_lglw);

  1703.             }

  1704. 

  1705.             int result;

  1706. 

  1707.             switch(_grabMode)

  1708.             {

  1709.                default:

  1710.                case LGLW_MOUSE_GRAB_NONE:

  1711.                   break;

  1712. 

  1713.                case LGLW_MOUSE_GRAB_CAPTURE:

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

  1715.                                         True/*owner_events*/,

  1716.                                         NoEventMask/*event_mask*/,

  1717.                                         GrabModeAsync/*pointer_mode*/,

  1718.                                         GrabModeAsync/*keyboard_mode*/,

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

  1720.                                         None/*cursor*/,

  1721.                                         CurrentTime/*time*/);

  1722.                   if(GrabSuccess != result)

  1723.                   {

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

  1725.                   }

  1726.                   else

  1727.                   {

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

  1729.                   }

  1730.                   break;

  1731. 

  1732.                case LGLW_MOUSE_GRAB_WARP:

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

  1734.                                         True/*owner_events*/,

  1735.                                         NoEventMask/*event_mask*/,

  1736.                                         GrabModeAsync/*pointer_mode*/,

  1737.                                         GrabModeAsync/*keyboard_mode*/,

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

  1739.                                         None/*cursor*/,

  1740.                                         CurrentTime/*time*/);

  1741.                   if(GrabSuccess != result)

  1742.                   {

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

  1744.                   }

  1745.                   else

  1746.                   {

  1747.                      lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  1751.                   }

  1752.                   break;

  1753.             }

  1754.          }

  1755.       }

  1756.    }

  1757. }

  1758. 

  1759. 

  1760. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  1761. void lglw_mouse_ungrab(lglw_t _lglw) {

  1762.    LGLW(_lglw);

  1763. 

  1764.    if(NULL != lglw)

  1765.    {

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

  1767.       {

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

  1769.          {

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

  1771.             {

  1772.                default:

  1773.                case LGLW_MOUSE_GRAB_NONE:

  1774.                   break;

  1775. 

  1776.                case LGLW_MOUSE_GRAB_CAPTURE:

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

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

  1779.                   break;

  1780. 

  1781.                case LGLW_MOUSE_GRAB_WARP:

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

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

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

  1785.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1786.                   break;

  1787.             }

  1788.          }

  1789.       }

  1790.    }

  1791. }

  1792. 

  1793. 

  1794. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1796.    LGLW(_lglw);

  1797. 

  1798.    if(NULL != lglw)

  1799.    {

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

  1801.       {

  1802.          XWarpPointer(lglw->xdsp,

  1803.                       None/*src_w*/,

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

  1805.                       0/*src_x*/,

  1806.                       0/*src_y*/,

  1807.                       0/*src_width*/,

  1808.                       0/*src_height*/,

  1809.                       _x/*dest_x*/,

  1810.                       _y/*dest_y*/);

  1811.       }

  1812.    }

  1813. }

  1814. 

  1815. 

  1816. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1817. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1819.    {

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

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

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

  1823.    }

  1824. }

  1825. 

  1826. 

  1827. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1829.    LGLW(_lglw);

  1830. 

  1831.    if(NULL != lglw)

  1832.    {

  1833.       if(LGLW_FALSE == _bShow)

  1834.       {

  1835.          Pixmap noPxm;

  1836.          Cursor noCursor;

  1837.          XColor black, dummy;

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

  1839. 

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

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

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

  1843. 

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

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

  1846.          if(noPxm != None)

  1847.          {

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

  1849.          }

  1850.       }

  1851.       else

  1852.       {

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

  1854.       }

  1855.    }

  1856. }

  1857. 

  1858. 

  1859. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1861.    LGLW(_lglw);

  1862. 

  1863.    if(NULL != lglw)

  1864.    {

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

  1866.       lglw->timer.interval_ms = _millisec;

  1867.       lglw->timer.b_running   = LGLW_TRUE;

  1868.    }

  1869. }

  1870. 

  1871. 

  1872. // ---------------------------------------------------------------------------- lglw_timer_stop

  1873. void lglw_timer_stop(lglw_t _lglw) {

  1874.    LGLW(_lglw);

  1875. 

  1876.    if(NULL != lglw)

  1877.    {

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

  1879.       lglw->timer.b_running = LGLW_FALSE;

  1880.    }

  1881. }

  1882. 

  1883. 

  1884. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1886.    LGLW(_lglw);

  1887. 

  1888.    if(NULL != lglw)

  1889.    {

  1890.       lglw->timer.cbk = _cbk;

  1891.    }

  1892. }

  1893. 

  1894. 

  1895. // ---------------------------------------------------------------------------- loc_process_timer()

  1896. static void loc_process_timer(lglw_int_t *lglw) {

  1897.    if(lglw->timer.b_running)

  1898.    {

  1899.       uint32_t ms = loc_millisec_delta(lglw);

  1900. 

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

  1902.       {

  1903.          lglw->timer.last_ms = ms;

  1904. 

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

  1906.          {

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

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

  1909.          }

  1910.       }

  1911.    }

  1912. }

  1913. 

  1914. 

  1915. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1917. 

  1918.    // (todo) implement me

  1919. }

  1920. 

  1921. 

  1922. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1924.    LGLW(_lglw);

  1925. 

  1926.    if(NULL != _lglw)

  1927.    {

  1928.       lglw->dropfiles.cbk = _cbk;

  1929. 

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

  1931.    }

  1932. }

  1933. 

  1934. 

  1935. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1937.    LGLW(_lglw);

  1938. 

  1939.    if(NULL != _lglw)

  1940.    {

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

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

  1943.    }

  1944. }

  1945. 

  1946. 

  1947. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1948. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1949.    lglw_bool_t r = LGLW_FALSE;

  1950.    LGLW(_lglw);

  1951. 

  1952.    if(NULL != _lglw)

  1953.    {

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

  1955.    }

  1956. 

  1957.    return r;

  1958. }

  1959. 

  1960. 

  1961. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1963.    LGLW(_lglw);

  1964.    (void)_numChars;

  1965. 

  1966.    if(NULL != _text)

  1967.    {

  1968.       if(NULL != _lglw)

  1969.       {

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

  1971.          {

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

  1973. 

  1974.             if(numChars > 0u)

  1975.             {

  1976.                lglw->clipboard.numChars = numChars;

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

  1978. 

  1979.                uint32_t i;

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

  1981.                {

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

  1983.                }

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

  1985. 

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

  1987. 

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

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

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

  1991.             }

  1992.          }

  1993.       }

  1994.    }

  1995. }

  1996. 

  1997. 

  1998. // ---------------------------------------------------------------------------- loc_is_clipboard_event

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

  2000.    return _xevent->type == SelectionNotify;

  2001. }

  2002. 

  2003. 

  2004. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  2006.    LGLW(_lglw);

  2007. 

  2008.    if(NULL != _retNumChars)

  2009.       *_retNumChars = 0u;

  2010. 

  2011.    if(NULL != _retText)

  2012.       *_retText = 0;

  2013. 

  2014.    if(_maxChars > 0u)

  2015.    {

  2016.       if(NULL != _lglw)

  2017.       {

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

  2019.          {

  2020.             Window owner;

  2021.             XEvent xev;

  2022.             XSelectionEvent *cbReq;

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

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

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

  2026. 

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

  2028.             if(owner == None)

  2029.             {

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

  2031.                return;

  2032.             }

  2033. 

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

  2035.             {

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

  2037. 

  2038.                uint32_t i = 0u;

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

  2040.                {

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

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

  2043.                      break;

  2044.                }

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

  2046. 

  2047.                if(NULL != _retNumChars)

  2048.                   *_retNumChars = i;

  2049. 

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

  2051.                return;

  2052.             }

  2053. 

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

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

  2056. 

  2057.             cbReq = (XSelectionEvent*)&xev;

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

  2059.             {

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

  2061.                return;

  2062.             }

  2063. 

  2064.             Atom returnType;

  2065.             int returnFormat;

  2066.             unsigned long size, returnSize, bytesLeft;

  2067.             unsigned char *propertyValue = NULL;

  2068. 

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

  2070.                                0/*offset*/,

  2071.                                0/*length*/,

  2072.                                False/*delete*/,

  2073.                                AnyPropertyType/*req_type*/,

  2074.                                &returnType/*actual_type_return*/,

  2075.                                &returnFormat/*actual_format_return*/,

  2076.                                &returnSize/*nitems_return*/,

  2077.                                &size/*bytes_after_return*/,

  2078.                                &propertyValue/*prop_return*/);

  2079.             XFree(propertyValue);

  2080. 

  2081.             if(utf8 != returnType)

  2082.             {

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

  2084.                return;

  2085.             }

  2086. 

  2087.             if(8u != returnFormat)

  2088.             {

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

  2090.                return;

  2091.             }

  2092. 

  2093.             if(_maxChars < size)

  2094.                size = _maxChars;

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

  2096. 

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

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

  2099.                                0/*offset*/,

  2100.                                size/*length*/,

  2101.                                True/*delete*/,

  2102.                                AnyPropertyType/*req_type*/,

  2103.                                &returnType/*actual_type_return*/,

  2104.                                &returnFormat/*actual_format_return*/,

  2105.                                &returnSize/*nitems_return*/,

  2106.                                &bytesLeft/*bytes_after_return*/,

  2107.                                &propertyValue/*prop_return*/);

  2108. 

  2109.             if(returnSize == 0)

  2110.             {

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

  2112.                return;

  2113.             }

  2114. 

  2115.             uint32_t i = 0u;

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

  2117.             {

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

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

  2120.                   break;

  2121.             }

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

  2123. 

  2124.             if(NULL != _retNumChars)

  2125.                *_retNumChars = i;

  2126. 

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

  2128.             XFree(propertyValue);

  2129.          }

  2130.       }

  2131.    }

  2132. }

  2133. 

  2134. 

  2135. // ---------------------------------------------------------------------------- lglw_events

  2136. void lglw_events(lglw_t _lglw) {

  2137.    LGLW(_lglw);

  2138. 

  2139.    if(NULL != lglw)

  2140.    {

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

  2142.       {

  2143.          XEvent xev;

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

  2145.          Dlog_v("lglw:lglw_events: (events: %i)\n", queued);

  2146.          while(queued)

  2147.          {

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

  2149.             loc_eventProc(&xev, lglw);

  2150.             queued--;

  2151.          }

  2152. 

  2153.          loc_process_timer(lglw);

  2154.       }

  2155.    }

  2156. }