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

1160 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. #ifdef ARCH_X64

  46. #include <sys/mman.h>

  47. #include <unistd.h>

  48. #endif // ARCH_X64

  49. 

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

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

  52. 

  53. // ---------------------------------------------------------------------------- macros and defines

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

  55. 

  56. #define LGLW_DEFAULT_HIDDEN_W  (800)

  57. #define LGLW_DEFAULT_HIDDEN_H  (600)

  58. 

  59. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  60. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  61. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  62. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  63. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  64. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  65. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  66. 

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

  68. 

  69. 

  70. // ---------------------------------------------------------------------------- structs and typedefs

  71. typedef struct lglw_int_s {

  72.    void        *user_data;    // arbitrary user data

  73.    Display     *xdsp;

  74.    XVisualInfo *vi;

  75.    Colormap     cmap;

  76.    Window       parent_xwnd;  // created by host

  77. 

  78.    struct {

  79.       lglw_vec2i_t size;

  80.       Window       xwnd;

  81.    } hidden;

  82. 

  83.    struct {

  84.       lglw_vec2i_t size;

  85.       Window       xwnd;

  86.       lglw_bool_t  mapped;

  87.       int32_t      swap_interval;

  88.    } win;

  89. 

  90.    GLXContext   ctx;

  91. 

  92.    struct {

  93.       GLXContext   ctx;

  94.       GLXDrawable  drw;

  95.    } prev;

  96. 

  97.    struct {

  98.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  99.       lglw_keyboard_fxn_t cbk;

  100.    } keyboard;

  101. 

  102.    struct {

  103.       lglw_vec2i_t     p;  // last seen mouse position

  104.       uint32_t         button_state;

  105.       lglw_mouse_fxn_t cbk;

  106.       struct {

  107.          uint32_t         mode;

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

  109.          lglw_bool_t      b_queue_warp;

  110.          lglw_vec2i_t     last_p;

  111.       } grab;

  112.       struct {

  113.          lglw_bool_t      b_enable;

  114.          lglw_bool_t      b_update_queued;

  115.          lglw_bool_t      b_syn_rmb;

  116.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  117.          uint32_t         hold_start_ms;

  118.          lglw_vec2i_t     hold_start_p;

  119.       } touch;

  120.    } mouse;

  121. 

  122.    struct {

  123.       uint32_t         state;

  124.       lglw_focus_fxn_t cbk;

  125.    } focus;

  126. 

  127.    struct {

  128.       lglw_bool_t      b_running;

  129.       lglw_timer_fxn_t cbk;

  130.    } timer;

  131. 

  132.    struct {

  133.       lglw_dropfiles_fxn_t cbk;

  134.    } dropfiles;

  135. 

  136.    struct {

  137.       lglw_redraw_fxn_t cbk;

  138.    } redraw;

  139. 

  140. } lglw_int_t;

  141. 

  142. 

  143. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  145. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  146. 

  147. static void loc_key_hook(lglw_int_t *lglw);

  148. static void loc_key_unhook(lglw_int_t *lglw);

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

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

  151. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  152. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  153. 

  154. static void loc_handle_mouseleave (lglw_int_t *lglw);

  155. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  157. static void loc_handle_mousemotion (lglw_int_t *lglw);

  158. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  159. static void loc_touchinput_update (lglw_int_t *lglw);

  160. 

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

  162. 

  163. 

  164. // ---------------------------------------------------------------------------- module vars

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

  166. 

  167. 

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

  169. // ---------------------------------------------------------------------------- lglw_log

  170. static FILE *logfile;

  171. 

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

  173.    fprintf(logfile, logData);

  174.    fflush(logfile);

  175. }

  176. 

  177. 

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

  179. // ---------------------------------------------------------------------------- xerror_log

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

  181.    char error_text[1024];

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

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

  184.    return 0;

  185. }

  186. 

  187. 

  188. // ---------------------------------------------------------------------------- lglw_init

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

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

  191. 

  192.    // TODO: remove/improve

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

  194.    XSetErrorHandler(xerror_handler);

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

  196. 

  197.    if(NULL != lglw)

  198.    {

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

  200. 

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

  202.       if(_w <= 16)

  203.          _w = LGLW_DEFAULT_HIDDEN_W;

  204. 

  205.       if(_h <= 16)

  206.          _h = LGLW_DEFAULT_HIDDEN_H;

  207. 

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

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

  210.       {

  211.          free(lglw);

  212.          lglw = NULL;

  213.       }

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

  215.    }

  216. 

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

  218. 

  219.    return lglw;

  220. }

  221. 

  222. 

  223. // ---------------------------------------------------------------------------- lglw_exit

  224. void lglw_exit(lglw_t _lglw) {

  225.    LGLW(_lglw);

  226. 

  227.    if(NULL != lglw)

  228.    {

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

  230. 

  231.       loc_destroy_hidden_window(lglw);

  232. 

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

  234. 

  235.       fclose(logfile);

  236.       free(lglw);

  237.    }

  238. }

  239. 

  240. 

  241. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  243.    LGLW(_lglw);

  244. 

  245.    if(NULL != lglw)

  246.    {

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

  248.       lglw->user_data = _userData;

  249.    }

  250. }

  251. 

  252. // ---------------------------------------------------------------------------- lglw_userdata_get

  253. void *lglw_userdata_get(lglw_t _lglw) {

  254.    LGLW(_lglw);

  255. 

  256.    if(NULL != lglw)

  257.    {

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

  259.       return lglw->user_data;

  260.    }

  261. 

  262.    return NULL;

  263. }

  264. 

  265. 

  266. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  268. 

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

  270. 

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

  272.    XSetWindowAttributes swa;

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

  274.    int screen;

  275. 

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

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

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

  279. 

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

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

  282. 

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

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

  285.    {

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

  287.       return LGLW_FALSE;

  288.    }

  289. 

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

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

  292. 

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

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

  295.    {

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

  297.       return LGLW_FALSE;

  298.    }

  299. 

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

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

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

  303. 

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

  305.    swa.border_pixel = 0;

  306.    swa.colormap = lglw->cmap;

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

  308.       0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  310. 

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

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

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

  314. 

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

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

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

  318. 

  319.    return LGLW_TRUE;

  320. }

  321. 

  322. 

  323. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  324. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  327.    {

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

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

  330.    }

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

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

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

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

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

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

  337. 

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

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

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

  341. }

  342. 

  343. 

  344. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  351. 

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

  353. void loc_eventProc(void *xevent) {

  354.    // lglw_log("XEventProc");

  355.    printf("XEventProc\n");

  356. }

  357. 

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

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

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

  361. // TODO: 32-bit support

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

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

  364. //    long temp[2];

  365. 

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

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

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

  369. 

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

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

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

  373. // }

  374. 

  375. #ifdef ARCH_X64

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

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

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

  379.    //

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

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

  382.    //

  383. 

  384.    // based on mach_override

  385.    static const unsigned char kJumpInstructions[] = {

  386.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  387.          0x00, 0x00, 0x00, 0x00,

  388.          0x00, 0x00, 0x00, 0x00

  389.    };

  390.    static const int kJumpAddress = 6;

  391. 

  392.    static char *ptr = 0;

  393.    if (!ptr) {

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

  395.                          getpagesize()/*PAGE_SIZE*/,

  396.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  397.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  398.                          0, 0);

  399.       if (ptr == MAP_FAILED) {

  400.          perror("mmap");

  401.          ptr = 0;

  402.          return;

  403.       } else {

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

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

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

  407.       }

  408.    }

  409. 

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

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

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

  413. }

  414. #else

  415. // Pulled from the eXT2 example

  416. // TODO: 32-bit support

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

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

  419. 

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

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

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

  423. }

  424. #endif // ARCH_X64

  425. 

  426. 

  427. // ---------------------------------------------------------------------------- lglw_window_open

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

  429.    lglw_bool_t r = LGLW_FALSE;

  430.    LGLW(_lglw);

  431. 

  432.    if(NULL != lglw)

  433.    {

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

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

  436. 

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

  438.       if(_w <= 16)

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

  440. 

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

  442.       if(_h <= 16)

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

  444. 

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

  446. 

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

  448.       XSetWindowAttributes swa;

  449.       XEvent event;

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

  451. 

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

  453.       swa.border_pixel = 0;

  454.       swa.colormap = lglw->cmap;

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

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

  457.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  459. 

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

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

  462. 

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

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

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

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

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

  468. 

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

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

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

  472.       if (0 != _parentHWNDOrNull)

  473.       {

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

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

  476.       }

  477. 

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

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

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

  481.       lglw->win.mapped = LGLW_TRUE;

  482. 

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

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

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

  486. 

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

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

  489. 

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

  491.    }

  492.    return r;

  493. }

  494. 

  495. 

  496. // ---------------------------------------------------------------------------- lglw_window_resize

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

  498.    lglw_bool_t r = LGLW_FALSE;

  499.    LGLW(_lglw);

  500. 

  501.    if(NULL != lglw)

  502.    {

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

  504.       {

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

  506.          r = LGLW_TRUE;

  507. 

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

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

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

  511. 

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

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

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

  515. 

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

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

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

  519. 

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

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

  522.          unsigned int num_children;

  523. 

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

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

  526.             return r;

  527. 

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

  529.          if(children)

  530.             XFree((char *)children);

  531. 

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

  533.          // Resize parent window (if any)

  534.          if(0 != parent)

  535.          {

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

  537.             int x, y;

  538.             unsigned int width, height;

  539.             unsigned int border_width;

  540.             unsigned int depth;

  541. 

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

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

  544.                return r;

  545. 

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

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

  548.          }

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

  550.       }

  551.    }

  552. 

  553.    return r;

  554. }

  555. 

  556. 

  557. // ---------------------------------------------------------------------------- lglw_window_close

  558. void lglw_window_close (lglw_t _lglw) {

  559.    LGLW(_lglw);

  560. 

  561.    if(NULL != lglw)

  562.    {

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

  564.       {

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

  566.          lglw_timer_stop(_lglw);

  567. 

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

  569.          loc_key_unhook(lglw);

  570. 

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

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

  573. 

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

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

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

  577.          lglw->win.xwnd = 0;

  578.          lglw->win.mapped = LGLW_FALSE;

  579.       }

  580.    }

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

  582. }

  583. 

  584. 

  585. // ---------------------------------------------------------------------------- lglw_window_show

  586. void lglw_window_show(lglw_t _lglw) {

  587.    LGLW(_lglw);

  588. 

  589.    if(NULL != lglw)

  590.    {

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

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

  593. 

  594.       lglw->win.mapped = LGLW_TRUE;

  595.    }

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

  597. }

  598. 

  599. 

  600. // ---------------------------------------------------------------------------- lglw_window_hide

  601. void lglw_window_hide(lglw_t _lglw) {

  602.    LGLW(_lglw);

  603. 

  604.    if(NULL != lglw)

  605.    {

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

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

  608. 

  609.       lglw->win.mapped = LGLW_FALSE;

  610.    }

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

  612. }

  613. 

  614. 

  615. // ---------------------------------------------------------------------------- lglw_window_is_visible

  616. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  617.    lglw_bool_t r = LGLW_FALSE;

  618.    LGLW(_lglw);

  619. 

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

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

  622.    {

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

  624.       r = lglw->win.mapped;

  625.    }

  626. 

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

  628.    return r;

  629. }

  630. 

  631. 

  632. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  634.    LGLW(_lglw);

  635. 

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

  637.    if(NULL != lglw)

  638.    {

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

  640.       {

  641.          if(NULL != _retX)

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

  643. 

  644.          if(NULL != _retY)

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

  646.       }

  647.    }

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

  649. }

  650. 

  651. 

  652. // ---------------------------------------------------------------------------- lglw_redraw

  653. void lglw_redraw(lglw_t _lglw) {

  654.    LGLW(_lglw);

  655. 

  656.    // (todo) implement me

  657. 

  658.    if(NULL != lglw)

  659.    {

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

  661.       {

  662.          // TODO Event Loop

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

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

  665.          XFlush(lglw->xdsp);

  666.       }

  667.    }

  668. }

  669. 

  670. 

  671. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  673.    LGLW(_lglw);

  674. 

  675.    if(NULL != lglw)

  676.    {

  677.       lglw->redraw.cbk = _cbk;

  678.    }

  679. }

  680. 

  681. 

  682. // ---------------------------------------------------------------------------- lglw_glcontext_push

  683. void lglw_glcontext_push(lglw_t _lglw) {

  684.    LGLW(_lglw);

  685. 

  686.    if(NULL != lglw)

  687.    {

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

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

  690. 

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

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

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

  694.       {

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

  696.       }

  697.    }

  698. }

  699. 

  700. 

  701. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  702. void lglw_glcontext_pop(lglw_t _lglw) {

  703.    LGLW(_lglw);

  704. 

  705.    if(NULL != lglw)

  706.    {

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

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

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

  710.       {

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

  712.       }

  713.    }

  714. }

  715. 

  716. 

  717. // ---------------------------------------------------------------------------- lglw_swap_buffers

  718. void lglw_swap_buffers(lglw_t _lglw) {

  719.    LGLW(_lglw);

  720. 

  721.    if(NULL != lglw)

  722.    {

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

  724.       {

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

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

  727.       }

  728.    }

  729. }

  730. 

  731. 

  732. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  735.    LGLW(_lglw);

  736. 

  737.    if(NULL != lglw)

  738.    {

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

  740.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  742.       if(NULL != glXSwapIntervalEXT)

  743.       {

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

  745.          glXSwapIntervalEXT(_ival);

  746.          lglw->win.swap_interval = _ival;

  747.       }

  748.    }

  749. }

  750. 

  751. 

  752. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  753. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  754.    LGLW(_lglw);

  755.    int32_t r = 0;

  756. 

  757.    if(NULL != lglw)

  758.    {

  759.       r = lglw->win.swap_interval;

  760.    }

  761. 

  762.    return r;

  763. }

  764. 

  765. 

  766. // ---------------------------------------------------------------------------- loc_key_hook

  767. static void loc_key_hook(lglw_int_t *lglw) {

  768.    loc_key_unhook(lglw);

  769. 

  770.    // (todo) implement me

  771. 

  772.    khook_lglw = lglw;

  773. }

  774. 

  775. 

  776. // ---------------------------------------------------------------------------- loc_key_unhook

  777. static void loc_key_unhook(lglw_int_t *lglw) {

  778. 

  779.    // (todo) implement me

  780.    if(khook_lglw == lglw)

  781.       khook_lglw = NULL;

  782. }

  783. 

  784. 

  785. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  786. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  787.    loc_key_unhook(lglw);

  788. 

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

  790. 

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

  792.    {

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

  794.    }

  795. 

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

  797. }

  798. 

  799. 

  800. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  801. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  802.    

  803.    loc_key_hook(lglw);

  804. 

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

  806. 

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

  808.    {

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

  810.    }

  811. 

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

  813. }

  814. 

  815. 

  816. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  818.    if(_bPressed)

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

  820.    else

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

  822. 

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

  824.    {

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

  826.    }

  827. }

  828. 

  829. 

  830. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  831. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  832. 

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

  834.    {

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

  836.    }

  837. }

  838. 

  839. 

  840. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  842.    LGLW(_lglw);

  843. 

  844.    if(NULL != lglw)

  845.    {

  846.       lglw->mouse.cbk = _cbk;

  847.    }

  848. }

  849. 

  850. 

  851. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  853.    LGLW(_lglw);

  854. 

  855.    if(NULL != lglw)

  856.    {

  857.       lglw->focus.cbk = _cbk;

  858.    }

  859. }

  860. 

  861. 

  862. // ---------------------------------------------------------------------------- loc_handle_key

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

  864.    lglw_bool_t r = LGLW_FALSE;

  865. 

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

  867.    {

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

  869.    }

  870. 

  871.    return r;

  872. }

  873. 

  874. 

  875. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  877.    LGLW(_lglw);

  878. 

  879.    if(NULL != lglw)

  880.    {

  881.       lglw->keyboard.cbk = _cbk;

  882.    }

  883. }

  884. 

  885. 

  886. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  887. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  888.    uint32_t r = 0u;

  889.    LGLW(_lglw);

  890. 

  891.    if(NULL != lglw)

  892.    {

  893.       r = lglw->keyboard.kmod_state;

  894.    }

  895. 

  896.    return r;

  897. }

  898. 

  899. 

  900. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  902.    LGLW(_lglw);

  903. 

  904.    // (todo) implement me

  905. 

  906.    if(NULL != lglw)

  907.    {

  908.    }

  909. }

  910. 

  911. 

  912. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  913. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  914.    uint32_t r = 0u;

  915.    LGLW(_lglw);

  916. 

  917.    if(NULL != lglw)

  918.    {

  919.       r = lglw->mouse.button_state;

  920.    }

  921. 

  922.    return r;

  923. }

  924. 

  925. 

  926. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  928.    LGLW(_lglw);

  929. 

  930.    if(NULL != lglw)

  931.    {

  932.       // (todo) implement me

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

  934.       {

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

  936.          {

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

  938.             {

  939.                lglw_mouse_ungrab(_lglw);

  940.             }

  941. 

  942.             switch(_grabMode)

  943.             {

  944.                default:

  945.                case LGLW_MOUSE_GRAB_NONE:

  946.                   break;

  947. 

  948.                case LGLW_MOUSE_GRAB_CAPTURE:

  949.                   // (todo) implement me

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

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

  952.                   break;

  953. 

  954.                case LGLW_MOUSE_GRAB_WARP:

  955.                   // (todo) implement me

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

  957.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  961.                   break;

  962.             }

  963.          }

  964.       }

  965.    }

  966. }

  967. 

  968. 

  969. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  970. void lglw_mouse_ungrab(lglw_t _lglw) {

  971.    LGLW(_lglw);

  972. 

  973.    if(NULL != lglw)

  974.    {

  975.       // (todo) implement me

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

  977.       {

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

  979.          {

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

  981.             {

  982.                default:

  983.                case LGLW_MOUSE_GRAB_NONE:

  984.                   break;

  985. 

  986.                case LGLW_MOUSE_GRAB_CAPTURE:

  987.                   // (todo) implement me

  988.                   // (void)ReleaseCapture();

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

  990.                   break;

  991. 

  992.                case LGLW_MOUSE_GRAB_WARP:

  993.                   // (todo) implement me

  994.                   // (void)ReleaseCapture();

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

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

  997.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  998.                   break;

  999.             }

  1000.          }

  1001.       }

  1002.    }

  1003. }

  1004. 

  1005. 

  1006. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1008.    LGLW(_lglw);

  1009. 

  1010.    // (todo) implement me

  1011. 

  1012.    if(NULL != lglw)

  1013.    {

  1014.    }

  1015. }

  1016. 

  1017. 

  1018. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1019. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1021.    {

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

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

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

  1025.    }

  1026. }

  1027. 

  1028. 

  1029. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1031.    LGLW(_lglw);

  1032. 

  1033.    // (todo) implement me

  1034. 

  1035.    if(NULL != lglw)

  1036.    {

  1037.    }

  1038. }

  1039. 

  1040. 

  1041. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1043.    LGLW(_lglw);

  1044. 

  1045.    // (todo) implement me

  1046. 

  1047.    if(NULL != lglw)

  1048.    {

  1049.    }

  1050. }

  1051. 

  1052. 

  1053. // ---------------------------------------------------------------------------- lglw_timer_stop

  1054. void lglw_timer_stop(lglw_t _lglw) {

  1055.    LGLW(_lglw);

  1056. 

  1057.    // (todo) implement me

  1058. 

  1059.    if(NULL != lglw)

  1060.    {

  1061.    }

  1062. }

  1063. 

  1064. 

  1065. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1067.    LGLW(_lglw);

  1068. 

  1069.    if(NULL != lglw)

  1070.    {

  1071.       lglw->timer.cbk = _cbk;

  1072.    }

  1073. }

  1074. 

  1075. 

  1076. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1078. 

  1079.    // (todo) implement me

  1080. }

  1081. 

  1082. 

  1083. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1085.    LGLW(_lglw);

  1086. 

  1087.    if(NULL != _lglw)

  1088.    {

  1089.       lglw->dropfiles.cbk = _cbk;

  1090. 

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

  1092.    }

  1093. }

  1094. 

  1095. 

  1096. // ---------------------------------------------------------------------------- loc_touchinput_update

  1097. static void loc_touchinput_update(lglw_int_t *lglw) {

  1098. 

  1099.    // (todo) implement me

  1100. }

  1101. 

  1102. 

  1103. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1105.    LGLW(_lglw);

  1106. 

  1107.    if(NULL != _lglw)

  1108.    {

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

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

  1111.    }

  1112. }

  1113. 

  1114. 

  1115. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1116. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1117.    lglw_bool_t r = LGLW_FALSE;

  1118.    LGLW(_lglw);

  1119. 

  1120.    if(NULL != _lglw)

  1121.    {

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

  1123.    }

  1124. 

  1125.    return r;

  1126. }

  1127. 

  1128. 

  1129. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1131.    LGLW(_lglw);

  1132.    (void)_numChars;

  1133. 

  1134.    // (todo) implement me

  1135. 

  1136.    if(NULL != _text)

  1137.    {

  1138.    }

  1139. }

  1140. 

  1141. 

  1142. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1144.    LGLW(_lglw);

  1145. 

  1146.    if(NULL != _retNumChars)

  1147.       *_retNumChars = 0u;

  1148. 

  1149.    if(NULL != _retText)

  1150.       *_retText = 0;

  1151. 

  1152.    if(_maxChars > 0u)

  1153.    {

  1154.       if(NULL != _lglw)

  1155.       {

  1156.          // (todo) implement me

  1157.       }

  1158.    }

  1159. }