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

1158 lines
34KB
Raw Blame History 

  1. /* ----

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

  3.  * ---- author : bsp

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

  5.  * ----

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

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

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

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

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

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

  12.  * ----

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

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

  15.  * ----

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

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

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

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

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

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

  22.  * ---- THE SOFTWARE.

  23.  * ----

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

  25.  * ----

  26.  * ---- created: 04Aug2018

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

  28.  * ----

  29.  * ----

  30.  */

  31. 

  32. #include "lglw.h"

  33. 

  34. #include <stdlib.h>

  35. #include <stdio.h>

  36. #include <string.h>

  37. 

  38. #include <X11/Xlib.h>

  39. #include <X11/Xutil.h>

  40. #include <X11/Xos.h>

  41. 

  42. #include <GL/gl.h>

  43. #include <GL/glx.h>

  44. 

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

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

  47. 

  48. // ---------------------------------------------------------------------------- macros and defines

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

  50. 

  51. #define LGLW_DEFAULT_HIDDEN_W  (800)

  52. #define LGLW_DEFAULT_HIDDEN_H  (600)

  53. 

  54. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  55. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  56. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  57. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  58. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  59. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  60. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  61. 

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

  63. 

  64. 

  65. // ---------------------------------------------------------------------------- structs and typedefs

  66. typedef struct lglw_int_s {

  67.    void        *user_data;    // arbitrary user data

  68.    Display     *xdsp;

  69.    XVisualInfo *vi;

  70.    Colormap     cmap;

  71.    Window       parent_xwnd;  // created by host

  72. 

  73.    struct {

  74.       lglw_vec2i_t size;

  75.       Window       xwnd;

  76.    } hidden;

  77. 

  78.    struct {

  79.       lglw_vec2i_t size;

  80.       Window       xwnd;

  81.       lglw_bool_t  mapped;

  82.       int32_t      swap_interval;

  83.    } win;

  84. 

  85.    GLXContext   ctx;

  86. 

  87.    struct {

  88.       GLXContext   ctx;

  89.       GLXDrawable  drw;

  90.    } prev;

  91. 

  92.    struct {

  93.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  94.       lglw_keyboard_fxn_t cbk;

  95.    } keyboard;

  96. 

  97.    struct {

  98.       lglw_vec2i_t     p;  // last seen mouse position

  99.       uint32_t         button_state;

  100.       lglw_mouse_fxn_t cbk;

  101.       struct {

  102.          uint32_t         mode;

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

  104.          lglw_bool_t      b_queue_warp;

  105.          lglw_vec2i_t     last_p;

  106.       } grab;

  107.       struct {

  108.          lglw_bool_t      b_enable;

  109.          lglw_bool_t      b_update_queued;

  110.          lglw_bool_t      b_syn_rmb;

  111.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  112.          uint32_t         hold_start_ms;

  113.          lglw_vec2i_t     hold_start_p;

  114.       } touch;

  115.    } mouse;

  116. 

  117.    struct {

  118.       uint32_t         state;

  119.       lglw_focus_fxn_t cbk;

  120.    } focus;

  121. 

  122.    struct {

  123.       lglw_bool_t      b_running;

  124.       lglw_timer_fxn_t cbk;

  125.    } timer;

  126. 

  127.    struct {

  128.       lglw_dropfiles_fxn_t cbk;

  129.    } dropfiles;

  130. 

  131.    struct {

  132.       lglw_redraw_fxn_t cbk;

  133.    } redraw;

  134. 

  135. } lglw_int_t;

  136. 

  137. 

  138. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  140. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  141. 

  142. static void loc_key_hook(lglw_int_t *lglw);

  143. static void loc_key_unhook(lglw_int_t *lglw);

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

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

  146. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  147. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  148. 

  149. static void loc_handle_mouseleave (lglw_int_t *lglw);

  150. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  152. static void loc_handle_mousemotion (lglw_int_t *lglw);

  153. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  154. static void loc_touchinput_update (lglw_int_t *lglw);

  155. 

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

  157. 

  158. 

  159. // ---------------------------------------------------------------------------- module vars

  160. static lglw_int_t *khook_lglw = NULL;  // currently key-hooked lglw instance (one at a time)

  161. 

  162. 

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

  164. // ---------------------------------------------------------------------------- lglw_log

  165. static FILE *logfile;

  166. 

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

  168.    fprintf(logfile, logData);

  169.    fflush(logfile);

  170. }

  171. 

  172. 

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

  174. // ---------------------------------------------------------------------------- xerror_log

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

  176.    char error_text[1024];

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

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

  179.    return 0;

  180. }

  181. 

  182. 

  183. // ---------------------------------------------------------------------------- lglw_init

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

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

  186. 

  187.    // TODO: remove/improve

  188.    logfile = fopen("/home/cameron/src/VeeSeeVSTRack/other/log.txt", "w");

  189.    XSetErrorHandler(xerror_handler);

  190. 

  191.    if(NULL != lglw)

  192.    {

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

  194. 

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

  196.       if(_w <= 16)

  197.          _w = LGLW_DEFAULT_HIDDEN_W;

  198. 

  199.       if(_h <= 16)

  200.          _h = LGLW_DEFAULT_HIDDEN_H;

  201. 

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

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

  204.       {

  205.          free(lglw);

  206.          lglw = NULL;

  207.       }

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

  209.    }

  210. 

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

  212. 

  213.    return lglw;

  214. }

  215. 

  216. 

  217. // ---------------------------------------------------------------------------- lglw_exit

  218. void lglw_exit(lglw_t _lglw) {

  219.    LGLW(_lglw);

  220. 

  221.    if(NULL != lglw)

  222.    {

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

  224. 

  225.       loc_destroy_hidden_window(lglw);

  226. 

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

  228. 

  229.       fclose(logfile);

  230.       free(lglw);

  231.    }

  232. }

  233. 

  234. 

  235. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  237.    LGLW(_lglw);

  238. 

  239.    if(NULL != lglw)

  240.    {

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

  242.       lglw->user_data = _userData;

  243.    }

  244. }

  245. 

  246. // ---------------------------------------------------------------------------- lglw_userdata_get

  247. void *lglw_userdata_get(lglw_t _lglw) {

  248.    LGLW(_lglw);

  249. 

  250.    if(NULL != lglw)

  251.    {

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

  253.       return lglw->user_data;

  254.    }

  255. 

  256.    return NULL;

  257. }

  258. 

  259. 

  260. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  262. 

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

  264. 

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

  266.    XSetWindowAttributes swa;

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

  268.    int screen;

  269. 

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

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

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

  273. 

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

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

  276. 

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

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

  279.    {

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

  281.       return LGLW_FALSE;

  282.    }

  283. 

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

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

  286. 

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

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

  289.    {

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

  291.       return LGLW_FALSE;

  292.    }

  293. 

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

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

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

  297. 

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

  299.    swa.border_pixel = 0;

  300.    swa.colormap = lglw->cmap;

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

  302.       0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  304. 

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

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

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

  308. 

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

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

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

  312. 

  313.    return LGLW_TRUE;

  314. }

  315. 

  316. 

  317. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  318. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  321.    {

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

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

  324.    }

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

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

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

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

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

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

  331. 

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

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

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

  335. }

  336. 

  337. 

  338. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  345. 

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

  347. void loc_eventProc(void *xevent) {

  348.    // lglw_log("XEventProc");

  349.    printf("XEventProc\n");

  350. }

  351. 

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

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

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

  355. // TODO: 32-bit support

  356. // void loc_setEventProc (Display *display, Window window) {

  357. //    size_t data = (size_t)loc_eventProc;

  358. //    long temp[2];

  359. 

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

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

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

  363. 

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

  365. //    XChangeProperty(display, window, atom, atom, 32,

  366. //       PropModeReplace, (unsigned char*)temp, 2);

  367. // }

  368. 

  369. // Pulled from the eXT2 example

  370. // TODO: 32-bit support

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

  372.    void* data = (void*)&loc_eventProc; // swapped the function name here

  373. 

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

  375.    XChangeProperty(display, window, atom, atom, 32,

  376.       PropModeReplace, (unsigned char*)&data, 1); // 1 instead of 2 will crash Ardour, 2 will not do anything

  377. }

  378. 

  379. // Pulled from the amsynth example

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

  381. // void loc_setEventProc (Display *display, Window window) {

  382. // #ifdef BUILD_64

  383. //    //

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

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

  386. //    //

  387. 

  388. //    // based on mach_override

  389. //    static const unsigned char kJumpInstructions[] = {

  390. //          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  391. //          0x00, 0x00, 0x00, 0x00,

  392. //          0x00, 0x00, 0x00, 0x00

  393. //    };

  394. //    static const int kJumpAddress = 6;

  395. 

  396. //    static char *ptr;

  397. //    if (!ptr) {

  398. //       ptr = (char *)mmap(0,

  399. //                      PAGE_SIZE,

  400. //                      PROT_READ | PROT_WRITE | PROT_EXEC,

  401. //                      MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  402. //                      0, 0);

  403. //       if (ptr == MAP_FAILED) {

  404. //          perror("mmap");

  405. //          ptr = 0;

  406. //          return;

  407. //       } else {

  408. //          memcpy(ptr, kJumpInstructions, sizeof(kJumpInstructions));

  409. //          *((uint64_t *)(ptr + kJumpAddress)) = (uint64_t)(&loc_eventProc);

  410. //          msync(ptr, sizeof(kJumpInstructions), MS_INVALIDATE);

  411. //       }

  412. //    }

  413. 

  414. //    long temp[2] = {(long)ptr, 0};

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

  416. //    XChangeProperty(display, window, atom, atom, 32, PropModeReplace, (unsigned char *)temp, 2);

  417. // #else

  418. //    long temp[1] = {(long)(void *)(&loc_eventProc)};

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

  420. //    XChangeProperty(display, window, atom, atom, 32, PropModeReplace, (unsigned char *)temp, 1);

  421. // #endif

  422. // }

  423. 

  424. 

  425. // ---------------------------------------------------------------------------- lglw_window_open

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

  427.    lglw_bool_t r = LGLW_FALSE;

  428.    LGLW(_lglw);

  429. 

  430.    if(NULL != lglw)

  431.    {

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

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

  434. 

  435.       lglw_log("lglw:lglw_window_open: 2\n");

  436.       if(_w <= 16)

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

  438. 

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

  440.       if(_h <= 16)

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

  442. 

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

  444. 

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

  446.       XSetWindowAttributes swa;

  447.       XEvent event;

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

  449. 

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

  451.       swa.border_pixel = 0;

  452.       swa.colormap = lglw->cmap;

  453.       swa.event_mask = EnterWindowMask | LeaveWindowMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;

  454.       lglw->win.xwnd = XCreateWindow(lglw->xdsp, DefaultRootWindow(lglw->xdsp),

  455.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  457. 

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

  459.       XSetStandardProperties(lglw->xdsp, lglw->win.xwnd, "LGLW", "LGLW", None, NULL, 0, NULL);

  460. 

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

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

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

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

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

  466. 

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

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

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

  470.       if (0 != _parentHWNDOrNull)

  471.       {

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

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

  474.       }

  475. 

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

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

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

  479.       lglw->win.mapped = LGLW_TRUE;

  480. 

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

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

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

  484. 

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

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

  487. 

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

  489.    }

  490.    return r;

  491. }

  492. 

  493. 

  494. // ---------------------------------------------------------------------------- lglw_window_resize

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

  496.    lglw_bool_t r = LGLW_FALSE;

  497.    LGLW(_lglw);

  498. 

  499.    if(NULL != lglw)

  500.    {

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

  502.       {

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

  504.          r = LGLW_TRUE;

  505. 

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

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

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

  509. 

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

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

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

  513. 

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

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

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

  517. 

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

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

  520.          unsigned int num_children;

  521. 

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

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

  524.             return r;

  525. 

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

  527.          if(children)

  528.             XFree((char *)children);

  529. 

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

  531.          // Resize parent window (if any)

  532.          if(0 != parent)

  533.          {

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

  535.             int x, y;

  536.             unsigned int width, height;

  537.             unsigned int border_width;

  538.             unsigned int depth;

  539. 

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

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

  542.                return r;

  543. 

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

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

  546.          }

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

  548.       }

  549.    }

  550. 

  551.    return r;

  552. }

  553. 

  554. 

  555. // ---------------------------------------------------------------------------- lglw_window_close

  556. void lglw_window_close (lglw_t _lglw) {

  557.    LGLW(_lglw);

  558. 

  559.    if(NULL != lglw)

  560.    {

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

  562.       {

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

  564.          lglw_timer_stop(_lglw);

  565. 

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

  567.          loc_key_unhook(lglw);

  568. 

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

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

  571. 

  572.          lglw_log("lglw:lglw_window_close: 4\n");

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

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

  575.          lglw->win.xwnd = 0;

  576.          lglw->win.mapped = LGLW_FALSE;

  577.       }

  578.    }

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

  580. }

  581. 

  582. 

  583. // ---------------------------------------------------------------------------- lglw_window_show

  584. void lglw_window_show(lglw_t _lglw) {

  585.    LGLW(_lglw);

  586. 

  587.    if(NULL != lglw)

  588.    {

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

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

  591. 

  592.       lglw->win.mapped = LGLW_TRUE;

  593.    }

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

  595. }

  596. 

  597. 

  598. // ---------------------------------------------------------------------------- lglw_window_hide

  599. void lglw_window_hide(lglw_t _lglw) {

  600.    LGLW(_lglw);

  601. 

  602.    if(NULL != lglw)

  603.    {

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

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

  606. 

  607.       lglw->win.mapped = LGLW_FALSE;

  608.    }

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

  610. }

  611. 

  612. 

  613. // ---------------------------------------------------------------------------- lglw_window_is_visible

  614. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  615.    lglw_bool_t r = LGLW_FALSE;

  616.    LGLW(_lglw);

  617. 

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

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

  620.    {

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

  622.       r = lglw->win.mapped;

  623.    }

  624. 

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

  626.    return r;

  627. }

  628. 

  629. 

  630. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  632.    LGLW(_lglw);

  633. 

  634.    lglw_log("lglw:lglw_window_size_get: 1\n");

  635.    if(NULL != lglw)

  636.    {

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

  638.       {

  639.          if(NULL != _retX)

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

  641. 

  642.          if(NULL != _retY)

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

  644.       }

  645.    }

  646.    lglw_log("lglw:lglw_window_size_get: EXIT\n");

  647. }

  648. 

  649. 

  650. // ---------------------------------------------------------------------------- lglw_redraw

  651. void lglw_redraw(lglw_t _lglw) {

  652.    LGLW(_lglw);

  653. 

  654.    // (todo) implement me

  655. 

  656.    if(NULL != lglw)

  657.    {

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

  659.       {

  660.          // TODO Event Loop

  661.          lglw_log("lglw:lglw_redraw: 1\n");

  662.          XClearArea(lglw->xdsp, lglw->win.xwnd, 0, 0, 1, 1, True); // clear tiny area for exposing

  663.          XFlush(lglw->xdsp);

  664.       }

  665.    }

  666. }

  667. 

  668. 

  669. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  671.    LGLW(_lglw);

  672. 

  673.    if(NULL != lglw)

  674.    {

  675.       lglw->redraw.cbk = _cbk;

  676.    }

  677. }

  678. 

  679. 

  680. // ---------------------------------------------------------------------------- lglw_glcontext_push

  681. void lglw_glcontext_push(lglw_t _lglw) {

  682.    LGLW(_lglw);

  683. 

  684.    if(NULL != lglw)

  685.    {

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

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

  688. 

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

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

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

  692.       {

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

  694.       }

  695.    }

  696. }

  697. 

  698. 

  699. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  700. void lglw_glcontext_pop(lglw_t _lglw) {

  701.    LGLW(_lglw);

  702. 

  703.    if(NULL != lglw)

  704.    {

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

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

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

  708.       {

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

  710.       }

  711.    }

  712. }

  713. 

  714. 

  715. // ---------------------------------------------------------------------------- lglw_swap_buffers

  716. void lglw_swap_buffers(lglw_t _lglw) {

  717.    LGLW(_lglw);

  718. 

  719.    if(NULL != lglw)

  720.    {

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

  722.       {

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

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

  725.       }

  726.    }

  727. }

  728. 

  729. 

  730. // ---------------------------------------------------------------------------- lglw_swap_interval_set

  731. typedef void (APIENTRY *PFNWGLEXTSWAPINTERVALPROC) (int);

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

  733.    LGLW(_lglw);

  734. 

  735.    if(NULL != lglw)

  736.    {

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

  738.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

  739.       glXSwapIntervalEXT = (PFNWGLEXTSWAPINTERVALPROC) glXGetProcAddress("glXSwapIntervalEXT");

  740.       if(NULL != glXSwapIntervalEXT)

  741.       {

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

  743.          glXSwapIntervalEXT(_ival);

  744.          lglw->win.swap_interval = _ival;

  745.       }

  746.    }

  747. }

  748. 

  749. 

  750. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  751. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  752.    LGLW(_lglw);

  753.    int32_t r = 0;

  754. 

  755.    if(NULL != lglw)

  756.    {

  757.       r = lglw->win.swap_interval;

  758.    }

  759. 

  760.    return r;

  761. }

  762. 

  763. 

  764. // ---------------------------------------------------------------------------- loc_key_hook

  765. static void loc_key_hook(lglw_int_t *lglw) {

  766.    loc_key_unhook(lglw);

  767. 

  768.    // (todo) implement me

  769. 

  770.    khook_lglw = lglw;

  771. }

  772. 

  773. 

  774. // ---------------------------------------------------------------------------- loc_key_unhook

  775. static void loc_key_unhook(lglw_int_t *lglw) {

  776. 

  777.    // (todo) implement me

  778.    if(khook_lglw == lglw)

  779.       khook_lglw = NULL;

  780. }

  781. 

  782. 

  783. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  784. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  785.    loc_key_unhook(lglw);

  786. 

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

  788. 

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

  790.    {

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

  792.    }

  793. 

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

  795. }

  796. 

  797. 

  798. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  799. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  800.    

  801.    loc_key_hook(lglw);

  802. 

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

  804. 

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

  806.    {

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

  808.    }

  809. 

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

  811. }

  812. 

  813. 

  814. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  816.    if(_bPressed)

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

  818.    else

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

  820. 

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

  822.    {

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

  824.    }

  825. }

  826. 

  827. 

  828. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  829. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  830. 

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

  832.    {

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

  834.    }

  835. }

  836. 

  837. 

  838. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  840.    LGLW(_lglw);

  841. 

  842.    if(NULL != lglw)

  843.    {

  844.       lglw->mouse.cbk = _cbk;

  845.    }

  846. }

  847. 

  848. 

  849. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  851.    LGLW(_lglw);

  852. 

  853.    if(NULL != lglw)

  854.    {

  855.       lglw->focus.cbk = _cbk;

  856.    }

  857. }

  858. 

  859. 

  860. // ---------------------------------------------------------------------------- loc_handle_key

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

  862.    lglw_bool_t r = LGLW_FALSE;

  863. 

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

  865.    {

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

  867.    }

  868. 

  869.    return r;

  870. }

  871. 

  872. 

  873. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  875.    LGLW(_lglw);

  876. 

  877.    if(NULL != lglw)

  878.    {

  879.       lglw->keyboard.cbk = _cbk;

  880.    }

  881. }

  882. 

  883. 

  884. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  885. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  886.    uint32_t r = 0u;

  887.    LGLW(_lglw);

  888. 

  889.    if(NULL != lglw)

  890.    {

  891.       r = lglw->keyboard.kmod_state;

  892.    }

  893. 

  894.    return r;

  895. }

  896. 

  897. 

  898. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  900.    LGLW(_lglw);

  901. 

  902.    // (todo) implement me

  903. 

  904.    if(NULL != lglw)

  905.    {

  906.    }

  907. }

  908. 

  909. 

  910. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  911. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  912.    uint32_t r = 0u;

  913.    LGLW(_lglw);

  914. 

  915.    if(NULL != lglw)

  916.    {

  917.       r = lglw->mouse.button_state;

  918.    }

  919. 

  920.    return r;

  921. }

  922. 

  923. 

  924. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  926.    LGLW(_lglw);

  927. 

  928.    if(NULL != lglw)

  929.    {

  930.       // (todo) implement me

  931.       // if(NULL != lglw->win.hwnd)

  932.       {

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

  934.          {

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

  936.             {

  937.                lglw_mouse_ungrab(_lglw);

  938.             }

  939. 

  940.             switch(_grabMode)

  941.             {

  942.                default:

  943.                case LGLW_MOUSE_GRAB_NONE:

  944.                   break;

  945. 

  946.                case LGLW_MOUSE_GRAB_CAPTURE:

  947.                   // (todo) implement me

  948.                   // (void)SetCapture(lglw->win.hwnd);

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

  950.                   break;

  951. 

  952.                case LGLW_MOUSE_GRAB_WARP:

  953.                   // (todo) implement me

  954.                   // (void)SetCapture(lglw->win.hwnd);

  955.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  959.                   break;

  960.             }

  961.          }

  962.       }

  963.    }

  964. }

  965. 

  966. 

  967. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  968. void lglw_mouse_ungrab(lglw_t _lglw) {

  969.    LGLW(_lglw);

  970. 

  971.    if(NULL != lglw)

  972.    {

  973.       // (todo) implement me

  974.       // if(NULL != lglw->win.hwnd)

  975.       {

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

  977.          {

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

  979.             {

  980.                default:

  981.                case LGLW_MOUSE_GRAB_NONE:

  982.                   break;

  983. 

  984.                case LGLW_MOUSE_GRAB_CAPTURE:

  985.                   // (todo) implement me

  986.                   // (void)ReleaseCapture();

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

  988.                   break;

  989. 

  990.                case LGLW_MOUSE_GRAB_WARP:

  991.                   // (todo) implement me

  992.                   // (void)ReleaseCapture();

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

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

  995.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  996.                   break;

  997.             }

  998.          }

  999.       }

  1000.    }

  1001. }

  1002. 

  1003. 

  1004. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1006.    LGLW(_lglw);

  1007. 

  1008.    // (todo) implement me

  1009. 

  1010.    if(NULL != lglw)

  1011.    {

  1012.    }

  1013. }

  1014. 

  1015. 

  1016. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1017. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1019.    {

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

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

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

  1023.    }

  1024. }

  1025. 

  1026. 

  1027. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1029.    LGLW(_lglw);

  1030. 

  1031.    // (todo) implement me

  1032. 

  1033.    if(NULL != lglw)

  1034.    {

  1035.    }

  1036. }

  1037. 

  1038. 

  1039. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1041.    LGLW(_lglw);

  1042. 

  1043.    // (todo) implement me

  1044. 

  1045.    if(NULL != lglw)

  1046.    {

  1047.    }

  1048. }

  1049. 

  1050. 

  1051. // ---------------------------------------------------------------------------- lglw_timer_stop

  1052. void lglw_timer_stop(lglw_t _lglw) {

  1053.    LGLW(_lglw);

  1054. 

  1055.    // (todo) implement me

  1056. 

  1057.    if(NULL != lglw)

  1058.    {

  1059.    }

  1060. }

  1061. 

  1062. 

  1063. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1065.    LGLW(_lglw);

  1066. 

  1067.    if(NULL != lglw)

  1068.    {

  1069.       lglw->timer.cbk = _cbk;

  1070.    }

  1071. }

  1072. 

  1073. 

  1074. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1076. 

  1077.    // (todo) implement me

  1078. }

  1079. 

  1080. 

  1081. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1083.    LGLW(_lglw);

  1084. 

  1085.    if(NULL != _lglw)

  1086.    {

  1087.       lglw->dropfiles.cbk = _cbk;

  1088. 

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

  1090.    }

  1091. }

  1092. 

  1093. 

  1094. // ---------------------------------------------------------------------------- loc_touchinput_update

  1095. static void loc_touchinput_update(lglw_int_t *lglw) {

  1096. 

  1097.    // (todo) implement me

  1098. }

  1099. 

  1100. 

  1101. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1103.    LGLW(_lglw);

  1104. 

  1105.    if(NULL != _lglw)

  1106.    {

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

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

  1109.    }

  1110. }

  1111. 

  1112. 

  1113. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1114. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1115.    lglw_bool_t r = LGLW_FALSE;

  1116.    LGLW(_lglw);

  1117. 

  1118.    if(NULL != _lglw)

  1119.    {

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

  1121.    }

  1122. 

  1123.    return r;

  1124. }

  1125. 

  1126. 

  1127. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1129.    LGLW(_lglw);

  1130.    (void)_numChars;

  1131. 

  1132.    // (todo) implement me

  1133. 

  1134.    if(NULL != _text)

  1135.    {

  1136.    }

  1137. }

  1138. 

  1139. 

  1140. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1142.    LGLW(_lglw);

  1143. 

  1144.    if(NULL != _retNumChars)

  1145.       *_retNumChars = 0u;

  1146. 

  1147.    if(NULL != _retText)

  1148.       *_retText = 0;

  1149. 

  1150.    if(_maxChars > 0u)

  1151.    {

  1152.       if(NULL != _lglw)

  1153.       {

  1154.          // (todo) implement me

  1155.       }

  1156.    }

  1157. }