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

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

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

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

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

  374.    //

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

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

  377.    //

  378. 

  379.    // based on mach_override

  380.    static const unsigned char kJumpInstructions[] = {

  381.          0xFF, 0x25, 0x00, 0x00, 0x00, 0x00,

  382.          0x00, 0x00, 0x00, 0x00,

  383.          0x00, 0x00, 0x00, 0x00

  384.    };

  385.    static const int kJumpAddress = 6;

  386. 

  387.    static char *ptr = 0;

  388.    if (!ptr) {

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

  390.                      PAGE_SIZE,

  391.                      PROT_READ | PROT_WRITE | PROT_EXEC,

  392.                      MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  393.                      0, 0);

  394.       if (ptr == MAP_FAILED) {

  395.          perror("mmap");

  396.          ptr = 0;

  397.          return;

  398.       } else {

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

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

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

  402.       }

  403.    }

  404. 

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

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

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

  408. }

  409. #else

  410. // Pulled from the eXT2 example

  411. // TODO: 32-bit support

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

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

  414. 

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

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

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

  418. }

  419. #endif // ARCH_X64

  420. 

  421. 

  422. // ---------------------------------------------------------------------------- lglw_window_open

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

  424.    lglw_bool_t r = LGLW_FALSE;

  425.    LGLW(_lglw);

  426. 

  427.    if(NULL != lglw)

  428.    {

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

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

  431. 

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

  433.       if(_w <= 16)

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

  435. 

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

  437.       if(_h <= 16)

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

  439. 

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

  441. 

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

  443.       XSetWindowAttributes swa;

  444.       XEvent event;

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

  446. 

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

  448.       swa.border_pixel = 0;

  449.       swa.colormap = lglw->cmap;

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

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

  452.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  454. 

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

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

  457. 

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

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

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

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

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

  463. 

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

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

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

  467.       if (0 != _parentHWNDOrNull)

  468.       {

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

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

  471.       }

  472. 

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

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

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

  476.       lglw->win.mapped = LGLW_TRUE;

  477. 

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

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

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

  481. 

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

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

  484. 

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

  486.    }

  487.    return r;

  488. }

  489. 

  490. 

  491. // ---------------------------------------------------------------------------- lglw_window_resize

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

  493.    lglw_bool_t r = LGLW_FALSE;

  494.    LGLW(_lglw);

  495. 

  496.    if(NULL != lglw)

  497.    {

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

  499.       {

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

  501.          r = LGLW_TRUE;

  502. 

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

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

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

  506. 

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

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

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

  510. 

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

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

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

  514. 

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

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

  517.          unsigned int num_children;

  518. 

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

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

  521.             return r;

  522. 

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

  524.          if(children)

  525.             XFree((char *)children);

  526. 

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

  528.          // Resize parent window (if any)

  529.          if(0 != parent)

  530.          {

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

  532.             int x, y;

  533.             unsigned int width, height;

  534.             unsigned int border_width;

  535.             unsigned int depth;

  536. 

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

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

  539.                return r;

  540. 

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

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

  543.          }

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

  545.       }

  546.    }

  547. 

  548.    return r;

  549. }

  550. 

  551. 

  552. // ---------------------------------------------------------------------------- lglw_window_close

  553. void lglw_window_close (lglw_t _lglw) {

  554.    LGLW(_lglw);

  555. 

  556.    if(NULL != lglw)

  557.    {

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

  559.       {

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

  561.          lglw_timer_stop(_lglw);

  562. 

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

  564.          loc_key_unhook(lglw);

  565. 

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

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

  568. 

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

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

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

  572.          lglw->win.xwnd = 0;

  573.          lglw->win.mapped = LGLW_FALSE;

  574.       }

  575.    }

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

  577. }

  578. 

  579. 

  580. // ---------------------------------------------------------------------------- lglw_window_show

  581. void lglw_window_show(lglw_t _lglw) {

  582.    LGLW(_lglw);

  583. 

  584.    if(NULL != lglw)

  585.    {

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

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

  588. 

  589.       lglw->win.mapped = LGLW_TRUE;

  590.    }

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

  592. }

  593. 

  594. 

  595. // ---------------------------------------------------------------------------- lglw_window_hide

  596. void lglw_window_hide(lglw_t _lglw) {

  597.    LGLW(_lglw);

  598. 

  599.    if(NULL != lglw)

  600.    {

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

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

  603. 

  604.       lglw->win.mapped = LGLW_FALSE;

  605.    }

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

  607. }

  608. 

  609. 

  610. // ---------------------------------------------------------------------------- lglw_window_is_visible

  611. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  612.    lglw_bool_t r = LGLW_FALSE;

  613.    LGLW(_lglw);

  614. 

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

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

  617.    {

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

  619.       r = lglw->win.mapped;

  620.    }

  621. 

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

  623.    return r;

  624. }

  625. 

  626. 

  627. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  629.    LGLW(_lglw);

  630. 

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

  632.    if(NULL != lglw)

  633.    {

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

  635.       {

  636.          if(NULL != _retX)

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

  638. 

  639.          if(NULL != _retY)

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

  641.       }

  642.    }

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

  644. }

  645. 

  646. 

  647. // ---------------------------------------------------------------------------- lglw_redraw

  648. void lglw_redraw(lglw_t _lglw) {

  649.    LGLW(_lglw);

  650. 

  651.    // (todo) implement me

  652. 

  653.    if(NULL != lglw)

  654.    {

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

  656.       {

  657.          // TODO Event Loop

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

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

  660.          XFlush(lglw->xdsp);

  661.       }

  662.    }

  663. }

  664. 

  665. 

  666. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  668.    LGLW(_lglw);

  669. 

  670.    if(NULL != lglw)

  671.    {

  672.       lglw->redraw.cbk = _cbk;

  673.    }

  674. }

  675. 

  676. 

  677. // ---------------------------------------------------------------------------- lglw_glcontext_push

  678. void lglw_glcontext_push(lglw_t _lglw) {

  679.    LGLW(_lglw);

  680. 

  681.    if(NULL != lglw)

  682.    {

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

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

  685. 

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

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

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

  689.       {

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

  691.       }

  692.    }

  693. }

  694. 

  695. 

  696. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  697. void lglw_glcontext_pop(lglw_t _lglw) {

  698.    LGLW(_lglw);

  699. 

  700.    if(NULL != lglw)

  701.    {

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

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

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

  705.       {

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

  707.       }

  708.    }

  709. }

  710. 

  711. 

  712. // ---------------------------------------------------------------------------- lglw_swap_buffers

  713. void lglw_swap_buffers(lglw_t _lglw) {

  714.    LGLW(_lglw);

  715. 

  716.    if(NULL != lglw)

  717.    {

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

  719.       {

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

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

  722.       }

  723.    }

  724. }

  725. 

  726. 

  727. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  730.    LGLW(_lglw);

  731. 

  732.    if(NULL != lglw)

  733.    {

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

  735.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  737.       if(NULL != glXSwapIntervalEXT)

  738.       {

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

  740.          glXSwapIntervalEXT(_ival);

  741.          lglw->win.swap_interval = _ival;

  742.       }

  743.    }

  744. }

  745. 

  746. 

  747. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  748. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  749.    LGLW(_lglw);

  750.    int32_t r = 0;

  751. 

  752.    if(NULL != lglw)

  753.    {

  754.       r = lglw->win.swap_interval;

  755.    }

  756. 

  757.    return r;

  758. }

  759. 

  760. 

  761. // ---------------------------------------------------------------------------- loc_key_hook

  762. static void loc_key_hook(lglw_int_t *lglw) {

  763.    loc_key_unhook(lglw);

  764. 

  765.    // (todo) implement me

  766. 

  767.    khook_lglw = lglw;

  768. }

  769. 

  770. 

  771. // ---------------------------------------------------------------------------- loc_key_unhook

  772. static void loc_key_unhook(lglw_int_t *lglw) {

  773. 

  774.    // (todo) implement me

  775.    if(khook_lglw == lglw)

  776.       khook_lglw = NULL;

  777. }

  778. 

  779. 

  780. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  781. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  782.    loc_key_unhook(lglw);

  783. 

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

  785. 

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

  787.    {

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

  789.    }

  790. 

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

  792. }

  793. 

  794. 

  795. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  796. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  797.    

  798.    loc_key_hook(lglw);

  799. 

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

  801. 

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

  803.    {

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

  805.    }

  806. 

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

  808. }

  809. 

  810. 

  811. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  813.    if(_bPressed)

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

  815.    else

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

  817. 

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

  819.    {

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

  821.    }

  822. }

  823. 

  824. 

  825. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  826. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  827. 

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

  829.    {

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

  831.    }

  832. }

  833. 

  834. 

  835. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  837.    LGLW(_lglw);

  838. 

  839.    if(NULL != lglw)

  840.    {

  841.       lglw->mouse.cbk = _cbk;

  842.    }

  843. }

  844. 

  845. 

  846. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  848.    LGLW(_lglw);

  849. 

  850.    if(NULL != lglw)

  851.    {

  852.       lglw->focus.cbk = _cbk;

  853.    }

  854. }

  855. 

  856. 

  857. // ---------------------------------------------------------------------------- loc_handle_key

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

  859.    lglw_bool_t r = LGLW_FALSE;

  860. 

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

  862.    {

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

  864.    }

  865. 

  866.    return r;

  867. }

  868. 

  869. 

  870. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  872.    LGLW(_lglw);

  873. 

  874.    if(NULL != lglw)

  875.    {

  876.       lglw->keyboard.cbk = _cbk;

  877.    }

  878. }

  879. 

  880. 

  881. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  882. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  883.    uint32_t r = 0u;

  884.    LGLW(_lglw);

  885. 

  886.    if(NULL != lglw)

  887.    {

  888.       r = lglw->keyboard.kmod_state;

  889.    }

  890. 

  891.    return r;

  892. }

  893. 

  894. 

  895. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  897.    LGLW(_lglw);

  898. 

  899.    // (todo) implement me

  900. 

  901.    if(NULL != lglw)

  902.    {

  903.    }

  904. }

  905. 

  906. 

  907. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  908. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  909.    uint32_t r = 0u;

  910.    LGLW(_lglw);

  911. 

  912.    if(NULL != lglw)

  913.    {

  914.       r = lglw->mouse.button_state;

  915.    }

  916. 

  917.    return r;

  918. }

  919. 

  920. 

  921. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  923.    LGLW(_lglw);

  924. 

  925.    if(NULL != lglw)

  926.    {

  927.       // (todo) implement me

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

  929.       {

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

  931.          {

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

  933.             {

  934.                lglw_mouse_ungrab(_lglw);

  935.             }

  936. 

  937.             switch(_grabMode)

  938.             {

  939.                default:

  940.                case LGLW_MOUSE_GRAB_NONE:

  941.                   break;

  942. 

  943.                case LGLW_MOUSE_GRAB_CAPTURE:

  944.                   // (todo) implement me

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

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

  947.                   break;

  948. 

  949.                case LGLW_MOUSE_GRAB_WARP:

  950.                   // (todo) implement me

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

  952.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  956.                   break;

  957.             }

  958.          }

  959.       }

  960.    }

  961. }

  962. 

  963. 

  964. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  965. void lglw_mouse_ungrab(lglw_t _lglw) {

  966.    LGLW(_lglw);

  967. 

  968.    if(NULL != lglw)

  969.    {

  970.       // (todo) implement me

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

  972.       {

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

  974.          {

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

  976.             {

  977.                default:

  978.                case LGLW_MOUSE_GRAB_NONE:

  979.                   break;

  980. 

  981.                case LGLW_MOUSE_GRAB_CAPTURE:

  982.                   // (todo) implement me

  983.                   // (void)ReleaseCapture();

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

  985.                   break;

  986. 

  987.                case LGLW_MOUSE_GRAB_WARP:

  988.                   // (todo) implement me

  989.                   // (void)ReleaseCapture();

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

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

  992.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  993.                   break;

  994.             }

  995.          }

  996.       }

  997.    }

  998. }

  999. 

  1000. 

  1001. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1003.    LGLW(_lglw);

  1004. 

  1005.    // (todo) implement me

  1006. 

  1007.    if(NULL != lglw)

  1008.    {

  1009.    }

  1010. }

  1011. 

  1012. 

  1013. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1014. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1016.    {

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

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

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

  1020.    }

  1021. }

  1022. 

  1023. 

  1024. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1026.    LGLW(_lglw);

  1027. 

  1028.    // (todo) implement me

  1029. 

  1030.    if(NULL != lglw)

  1031.    {

  1032.    }

  1033. }

  1034. 

  1035. 

  1036. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1038.    LGLW(_lglw);

  1039. 

  1040.    // (todo) implement me

  1041. 

  1042.    if(NULL != lglw)

  1043.    {

  1044.    }

  1045. }

  1046. 

  1047. 

  1048. // ---------------------------------------------------------------------------- lglw_timer_stop

  1049. void lglw_timer_stop(lglw_t _lglw) {

  1050.    LGLW(_lglw);

  1051. 

  1052.    // (todo) implement me

  1053. 

  1054.    if(NULL != lglw)

  1055.    {

  1056.    }

  1057. }

  1058. 

  1059. 

  1060. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1062.    LGLW(_lglw);

  1063. 

  1064.    if(NULL != lglw)

  1065.    {

  1066.       lglw->timer.cbk = _cbk;

  1067.    }

  1068. }

  1069. 

  1070. 

  1071. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1073. 

  1074.    // (todo) implement me

  1075. }

  1076. 

  1077. 

  1078. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1080.    LGLW(_lglw);

  1081. 

  1082.    if(NULL != _lglw)

  1083.    {

  1084.       lglw->dropfiles.cbk = _cbk;

  1085. 

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

  1087.    }

  1088. }

  1089. 

  1090. 

  1091. // ---------------------------------------------------------------------------- loc_touchinput_update

  1092. static void loc_touchinput_update(lglw_int_t *lglw) {

  1093. 

  1094.    // (todo) implement me

  1095. }

  1096. 

  1097. 

  1098. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1100.    LGLW(_lglw);

  1101. 

  1102.    if(NULL != _lglw)

  1103.    {

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

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

  1106.    }

  1107. }

  1108. 

  1109. 

  1110. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1111. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1112.    lglw_bool_t r = LGLW_FALSE;

  1113.    LGLW(_lglw);

  1114. 

  1115.    if(NULL != _lglw)

  1116.    {

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

  1118.    }

  1119. 

  1120.    return r;

  1121. }

  1122. 

  1123. 

  1124. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1126.    LGLW(_lglw);

  1127.    (void)_numChars;

  1128. 

  1129.    // (todo) implement me

  1130. 

  1131.    if(NULL != _text)

  1132.    {

  1133.    }

  1134. }

  1135. 

  1136. 

  1137. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1139.    LGLW(_lglw);

  1140. 

  1141.    if(NULL != _retNumChars)

  1142.       *_retNumChars = 0u;

  1143. 

  1144.    if(NULL != _retText)

  1145.       *_retText = 0;

  1146. 

  1147.    if(_maxChars > 0u)

  1148.    {

  1149.       if(NULL != _lglw)

  1150.       {

  1151.          // (todo) implement me

  1152.       }

  1153.    }

  1154. }