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

1159 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("/tmp/lglw_log.txt", "w");

  189.    XSetErrorHandler(xerror_handler);

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

  191. 

  192.    if(NULL != lglw)

  193.    {

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

  195. 

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

  197.       if(_w <= 16)

  198.          _w = LGLW_DEFAULT_HIDDEN_W;

  199. 

  200.       if(_h <= 16)

  201.          _h = LGLW_DEFAULT_HIDDEN_H;

  202. 

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

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

  205.       {

  206.          free(lglw);

  207.          lglw = NULL;

  208.       }

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

  210.    }

  211. 

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

  213. 

  214.    return lglw;

  215. }

  216. 

  217. 

  218. // ---------------------------------------------------------------------------- lglw_exit

  219. void lglw_exit(lglw_t _lglw) {

  220.    LGLW(_lglw);

  221. 

  222.    if(NULL != lglw)

  223.    {

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

  225. 

  226.       loc_destroy_hidden_window(lglw);

  227. 

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

  229. 

  230.       fclose(logfile);

  231.       free(lglw);

  232.    }

  233. }

  234. 

  235. 

  236. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  238.    LGLW(_lglw);

  239. 

  240.    if(NULL != lglw)

  241.    {

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

  243.       lglw->user_data = _userData;

  244.    }

  245. }

  246. 

  247. // ---------------------------------------------------------------------------- lglw_userdata_get

  248. void *lglw_userdata_get(lglw_t _lglw) {

  249.    LGLW(_lglw);

  250. 

  251.    if(NULL != lglw)

  252.    {

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

  254.       return lglw->user_data;

  255.    }

  256. 

  257.    return NULL;

  258. }

  259. 

  260. 

  261. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  263. 

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

  265. 

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

  267.    XSetWindowAttributes swa;

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

  269.    int screen;

  270. 

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

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

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

  274. 

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

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

  277. 

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

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

  280.    {

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

  282.       return LGLW_FALSE;

  283.    }

  284. 

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

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

  287. 

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

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

  290.    {

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

  292.       return LGLW_FALSE;

  293.    }

  294. 

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

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

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

  298. 

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

  300.    swa.border_pixel = 0;

  301.    swa.colormap = lglw->cmap;

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

  303.       0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  305. 

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

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

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

  309. 

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

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

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

  313. 

  314.    return LGLW_TRUE;

  315. }

  316. 

  317. 

  318. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  319. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  322.    {

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

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

  325.    }

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

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

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

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

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

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

  332. 

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

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

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

  336. }

  337. 

  338. 

  339. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  346. 

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

  348. void loc_eventProc(void *xevent) {

  349.    // lglw_log("XEventProc");

  350.    printf("XEventProc\n");

  351. }

  352. 

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

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

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

  356. // TODO: 32-bit support

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

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

  359. //    long temp[2];

  360. 

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

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

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

  364. 

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

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

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

  368. // }

  369. 

  370. // Pulled from the eXT2 example

  371. // TODO: 32-bit support

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

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

  374. 

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

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

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

  378. }

  379. 

  380. // Pulled from the amsynth example

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

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

  383. // #ifdef BUILD_64

  384. //    //

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

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

  387. //    //

  388. 

  389. //    // based on mach_override

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

  391. //          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

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

  393. //          0x00, 0x00, 0x00, 0x00

  394. //    };

  395. //    static const int kJumpAddress = 6;

  396. 

  397. //    static char *ptr;

  398. //    if (!ptr) {

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

  400. //                      PAGE_SIZE,

  401. //                      PROT_READ | PROT_WRITE | PROT_EXEC,

  402. //                      MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  403. //                      0, 0);

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

  405. //          perror("mmap");

  406. //          ptr = 0;

  407. //          return;

  408. //       } else {

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

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

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

  412. //       }

  413. //    }

  414. 

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

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

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

  418. // #else

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

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

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

  422. // #endif

  423. // }

  424. 

  425. 

  426. // ---------------------------------------------------------------------------- lglw_window_open

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

  428.    lglw_bool_t r = LGLW_FALSE;

  429.    LGLW(_lglw);

  430. 

  431.    if(NULL != lglw)

  432.    {

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

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

  435. 

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

  437.       if(_w <= 16)

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

  439. 

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

  441.       if(_h <= 16)

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

  443. 

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

  445. 

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

  447.       XSetWindowAttributes swa;

  448.       XEvent event;

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

  450. 

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

  452.       swa.border_pixel = 0;

  453.       swa.colormap = lglw->cmap;

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

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

  456.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  458. 

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

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

  461. 

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

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

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

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

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

  467. 

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

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

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

  471.       if (0 != _parentHWNDOrNull)

  472.       {

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

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

  475.       }

  476. 

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

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

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

  480.       lglw->win.mapped = LGLW_TRUE;

  481. 

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

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

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

  485. 

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

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

  488. 

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

  490.    }

  491.    return r;

  492. }

  493. 

  494. 

  495. // ---------------------------------------------------------------------------- lglw_window_resize

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

  497.    lglw_bool_t r = LGLW_FALSE;

  498.    LGLW(_lglw);

  499. 

  500.    if(NULL != lglw)

  501.    {

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

  503.       {

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

  505.          r = LGLW_TRUE;

  506. 

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

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

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

  510. 

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

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

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

  514. 

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

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

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

  518. 

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

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

  521.          unsigned int num_children;

  522. 

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

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

  525.             return r;

  526. 

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

  528.          if(children)

  529.             XFree((char *)children);

  530. 

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

  532.          // Resize parent window (if any)

  533.          if(0 != parent)

  534.          {

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

  536.             int x, y;

  537.             unsigned int width, height;

  538.             unsigned int border_width;

  539.             unsigned int depth;

  540. 

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

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

  543.                return r;

  544. 

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

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

  547.          }

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

  549.       }

  550.    }

  551. 

  552.    return r;

  553. }

  554. 

  555. 

  556. // ---------------------------------------------------------------------------- lglw_window_close

  557. void lglw_window_close (lglw_t _lglw) {

  558.    LGLW(_lglw);

  559. 

  560.    if(NULL != lglw)

  561.    {

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

  563.       {

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

  565.          lglw_timer_stop(_lglw);

  566. 

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

  568.          loc_key_unhook(lglw);

  569. 

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

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

  572. 

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

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

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

  576.          lglw->win.xwnd = 0;

  577.          lglw->win.mapped = LGLW_FALSE;

  578.       }

  579.    }

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

  581. }

  582. 

  583. 

  584. // ---------------------------------------------------------------------------- lglw_window_show

  585. void lglw_window_show(lglw_t _lglw) {

  586.    LGLW(_lglw);

  587. 

  588.    if(NULL != lglw)

  589.    {

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

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

  592. 

  593.       lglw->win.mapped = LGLW_TRUE;

  594.    }

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

  596. }

  597. 

  598. 

  599. // ---------------------------------------------------------------------------- lglw_window_hide

  600. void lglw_window_hide(lglw_t _lglw) {

  601.    LGLW(_lglw);

  602. 

  603.    if(NULL != lglw)

  604.    {

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

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

  607. 

  608.       lglw->win.mapped = LGLW_FALSE;

  609.    }

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

  611. }

  612. 

  613. 

  614. // ---------------------------------------------------------------------------- lglw_window_is_visible

  615. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  616.    lglw_bool_t r = LGLW_FALSE;

  617.    LGLW(_lglw);

  618. 

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

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

  621.    {

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

  623.       r = lglw->win.mapped;

  624.    }

  625. 

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

  627.    return r;

  628. }

  629. 

  630. 

  631. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  633.    LGLW(_lglw);

  634. 

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

  636.    if(NULL != lglw)

  637.    {

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

  639.       {

  640.          if(NULL != _retX)

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

  642. 

  643.          if(NULL != _retY)

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

  645.       }

  646.    }

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

  648. }

  649. 

  650. 

  651. // ---------------------------------------------------------------------------- lglw_redraw

  652. void lglw_redraw(lglw_t _lglw) {

  653.    LGLW(_lglw);

  654. 

  655.    // (todo) implement me

  656. 

  657.    if(NULL != lglw)

  658.    {

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

  660.       {

  661.          // TODO Event Loop

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

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

  664.          XFlush(lglw->xdsp);

  665.       }

  666.    }

  667. }

  668. 

  669. 

  670. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  672.    LGLW(_lglw);

  673. 

  674.    if(NULL != lglw)

  675.    {

  676.       lglw->redraw.cbk = _cbk;

  677.    }

  678. }

  679. 

  680. 

  681. // ---------------------------------------------------------------------------- lglw_glcontext_push

  682. void lglw_glcontext_push(lglw_t _lglw) {

  683.    LGLW(_lglw);

  684. 

  685.    if(NULL != lglw)

  686.    {

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

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

  689. 

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

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

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

  693.       {

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

  695.       }

  696.    }

  697. }

  698. 

  699. 

  700. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  701. void lglw_glcontext_pop(lglw_t _lglw) {

  702.    LGLW(_lglw);

  703. 

  704.    if(NULL != lglw)

  705.    {

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

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

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

  709.       {

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

  711.       }

  712.    }

  713. }

  714. 

  715. 

  716. // ---------------------------------------------------------------------------- lglw_swap_buffers

  717. void lglw_swap_buffers(lglw_t _lglw) {

  718.    LGLW(_lglw);

  719. 

  720.    if(NULL != lglw)

  721.    {

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

  723.       {

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

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

  726.       }

  727.    }

  728. }

  729. 

  730. 

  731. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  734.    LGLW(_lglw);

  735. 

  736.    if(NULL != lglw)

  737.    {

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

  739.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  741.       if(NULL != glXSwapIntervalEXT)

  742.       {

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

  744.          glXSwapIntervalEXT(_ival);

  745.          lglw->win.swap_interval = _ival;

  746.       }

  747.    }

  748. }

  749. 

  750. 

  751. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  752. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  753.    LGLW(_lglw);

  754.    int32_t r = 0;

  755. 

  756.    if(NULL != lglw)

  757.    {

  758.       r = lglw->win.swap_interval;

  759.    }

  760. 

  761.    return r;

  762. }

  763. 

  764. 

  765. // ---------------------------------------------------------------------------- loc_key_hook

  766. static void loc_key_hook(lglw_int_t *lglw) {

  767.    loc_key_unhook(lglw);

  768. 

  769.    // (todo) implement me

  770. 

  771.    khook_lglw = lglw;

  772. }

  773. 

  774. 

  775. // ---------------------------------------------------------------------------- loc_key_unhook

  776. static void loc_key_unhook(lglw_int_t *lglw) {

  777. 

  778.    // (todo) implement me

  779.    if(khook_lglw == lglw)

  780.       khook_lglw = NULL;

  781. }

  782. 

  783. 

  784. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  785. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  786.    loc_key_unhook(lglw);

  787. 

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

  789. 

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

  791.    {

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

  793.    }

  794. 

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

  796. }

  797. 

  798. 

  799. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  800. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  801.    

  802.    loc_key_hook(lglw);

  803. 

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

  805. 

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

  807.    {

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

  809.    }

  810. 

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

  812. }

  813. 

  814. 

  815. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  817.    if(_bPressed)

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

  819.    else

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

  821. 

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

  823.    {

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

  825.    }

  826. }

  827. 

  828. 

  829. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  830. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  831. 

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

  833.    {

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

  835.    }

  836. }

  837. 

  838. 

  839. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  841.    LGLW(_lglw);

  842. 

  843.    if(NULL != lglw)

  844.    {

  845.       lglw->mouse.cbk = _cbk;

  846.    }

  847. }

  848. 

  849. 

  850. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  852.    LGLW(_lglw);

  853. 

  854.    if(NULL != lglw)

  855.    {

  856.       lglw->focus.cbk = _cbk;

  857.    }

  858. }

  859. 

  860. 

  861. // ---------------------------------------------------------------------------- loc_handle_key

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

  863.    lglw_bool_t r = LGLW_FALSE;

  864. 

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

  866.    {

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

  868.    }

  869. 

  870.    return r;

  871. }

  872. 

  873. 

  874. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  876.    LGLW(_lglw);

  877. 

  878.    if(NULL != lglw)

  879.    {

  880.       lglw->keyboard.cbk = _cbk;

  881.    }

  882. }

  883. 

  884. 

  885. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  886. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  887.    uint32_t r = 0u;

  888.    LGLW(_lglw);

  889. 

  890.    if(NULL != lglw)

  891.    {

  892.       r = lglw->keyboard.kmod_state;

  893.    }

  894. 

  895.    return r;

  896. }

  897. 

  898. 

  899. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  901.    LGLW(_lglw);

  902. 

  903.    // (todo) implement me

  904. 

  905.    if(NULL != lglw)

  906.    {

  907.    }

  908. }

  909. 

  910. 

  911. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  912. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  913.    uint32_t r = 0u;

  914.    LGLW(_lglw);

  915. 

  916.    if(NULL != lglw)

  917.    {

  918.       r = lglw->mouse.button_state;

  919.    }

  920. 

  921.    return r;

  922. }

  923. 

  924. 

  925. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  927.    LGLW(_lglw);

  928. 

  929.    if(NULL != lglw)

  930.    {

  931.       // (todo) implement me

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

  933.       {

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

  935.          {

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

  937.             {

  938.                lglw_mouse_ungrab(_lglw);

  939.             }

  940. 

  941.             switch(_grabMode)

  942.             {

  943.                default:

  944.                case LGLW_MOUSE_GRAB_NONE:

  945.                   break;

  946. 

  947.                case LGLW_MOUSE_GRAB_CAPTURE:

  948.                   // (todo) implement me

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

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

  951.                   break;

  952. 

  953.                case LGLW_MOUSE_GRAB_WARP:

  954.                   // (todo) implement me

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

  956.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  960.                   break;

  961.             }

  962.          }

  963.       }

  964.    }

  965. }

  966. 

  967. 

  968. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  969. void lglw_mouse_ungrab(lglw_t _lglw) {

  970.    LGLW(_lglw);

  971. 

  972.    if(NULL != lglw)

  973.    {

  974.       // (todo) implement me

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

  976.       {

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

  978.          {

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

  980.             {

  981.                default:

  982.                case LGLW_MOUSE_GRAB_NONE:

  983.                   break;

  984. 

  985.                case LGLW_MOUSE_GRAB_CAPTURE:

  986.                   // (todo) implement me

  987.                   // (void)ReleaseCapture();

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

  989.                   break;

  990. 

  991.                case LGLW_MOUSE_GRAB_WARP:

  992.                   // (todo) implement me

  993.                   // (void)ReleaseCapture();

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

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

  996.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  997.                   break;

  998.             }

  999.          }

  1000.       }

  1001.    }

  1002. }

  1003. 

  1004. 

  1005. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1007.    LGLW(_lglw);

  1008. 

  1009.    // (todo) implement me

  1010. 

  1011.    if(NULL != lglw)

  1012.    {

  1013.    }

  1014. }

  1015. 

  1016. 

  1017. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1018. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1020.    {

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

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

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

  1024.    }

  1025. }

  1026. 

  1027. 

  1028. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1030.    LGLW(_lglw);

  1031. 

  1032.    // (todo) implement me

  1033. 

  1034.    if(NULL != lglw)

  1035.    {

  1036.    }

  1037. }

  1038. 

  1039. 

  1040. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1042.    LGLW(_lglw);

  1043. 

  1044.    // (todo) implement me

  1045. 

  1046.    if(NULL != lglw)

  1047.    {

  1048.    }

  1049. }

  1050. 

  1051. 

  1052. // ---------------------------------------------------------------------------- lglw_timer_stop

  1053. void lglw_timer_stop(lglw_t _lglw) {

  1054.    LGLW(_lglw);

  1055. 

  1056.    // (todo) implement me

  1057. 

  1058.    if(NULL != lglw)

  1059.    {

  1060.    }

  1061. }

  1062. 

  1063. 

  1064. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1066.    LGLW(_lglw);

  1067. 

  1068.    if(NULL != lglw)

  1069.    {

  1070.       lglw->timer.cbk = _cbk;

  1071.    }

  1072. }

  1073. 

  1074. 

  1075. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1077. 

  1078.    // (todo) implement me

  1079. }

  1080. 

  1081. 

  1082. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1084.    LGLW(_lglw);

  1085. 

  1086.    if(NULL != _lglw)

  1087.    {

  1088.       lglw->dropfiles.cbk = _cbk;

  1089. 

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

  1091.    }

  1092. }

  1093. 

  1094. 

  1095. // ---------------------------------------------------------------------------- loc_touchinput_update

  1096. static void loc_touchinput_update(lglw_int_t *lglw) {

  1097. 

  1098.    // (todo) implement me

  1099. }

  1100. 

  1101. 

  1102. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1104.    LGLW(_lglw);

  1105. 

  1106.    if(NULL != _lglw)

  1107.    {

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

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

  1110.    }

  1111. }

  1112. 

  1113. 

  1114. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1115. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1116.    lglw_bool_t r = LGLW_FALSE;

  1117.    LGLW(_lglw);

  1118. 

  1119.    if(NULL != _lglw)

  1120.    {

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

  1122.    }

  1123. 

  1124.    return r;

  1125. }

  1126. 

  1127. 

  1128. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1130.    LGLW(_lglw);

  1131.    (void)_numChars;

  1132. 

  1133.    // (todo) implement me

  1134. 

  1135.    if(NULL != _text)

  1136.    {

  1137.    }

  1138. }

  1139. 

  1140. 

  1141. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1143.    LGLW(_lglw);

  1144. 

  1145.    if(NULL != _retNumChars)

  1146.       *_retNumChars = 0u;

  1147. 

  1148.    if(NULL != _retText)

  1149.       *_retText = 0;

  1150. 

  1151.    if(_maxChars > 0u)

  1152.    {

  1153.       if(NULL != _lglw)

  1154.       {

  1155.          // (todo) implement me

  1156.       }

  1157.    }

  1158. }