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

1177 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.       lglw_bool_t  b_owner;

  89.    } win;

  90. 

  91.    GLXContext   ctx;

  92. 

  93.    struct {

  94.       GLXContext   ctx;

  95.       GLXDrawable  drw;

  96.    } prev;

  97. 

  98.    struct {

  99.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  100.       lglw_keyboard_fxn_t cbk;

  101.    } keyboard;

  102. 

  103.    struct {

  104.       lglw_vec2i_t     p;  // last seen mouse position

  105.       uint32_t         button_state;

  106.       lglw_mouse_fxn_t cbk;

  107.       struct {

  108.          uint32_t         mode;

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

  110.          lglw_bool_t      b_queue_warp;

  111.          lglw_vec2i_t     last_p;

  112.       } grab;

  113.       struct {

  114.          lglw_bool_t      b_enable;

  115.          lglw_bool_t      b_update_queued;

  116.          lglw_bool_t      b_syn_rmb;

  117.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  118.          uint32_t         hold_start_ms;

  119.          lglw_vec2i_t     hold_start_p;

  120.       } touch;

  121.    } mouse;

  122. 

  123.    struct {

  124.       uint32_t         state;

  125.       lglw_focus_fxn_t cbk;

  126.    } focus;

  127. 

  128.    struct {

  129.       lglw_bool_t      b_running;

  130.       lglw_timer_fxn_t cbk;

  131.    } timer;

  132. 

  133.    struct {

  134.       lglw_dropfiles_fxn_t cbk;

  135.    } dropfiles;

  136. 

  137.    struct {

  138.       lglw_redraw_fxn_t cbk;

  139.    } redraw;

  140. 

  141. } lglw_int_t;

  142. 

  143. 

  144. // ---------------------------------------------------------------------------- module fxn fwd decls

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

  146. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  147. 

  148. static void loc_key_hook(lglw_int_t *lglw);

  149. static void loc_key_unhook(lglw_int_t *lglw);

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

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

  152. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  153. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  154. 

  155. static void loc_handle_mouseleave (lglw_int_t *lglw);

  156. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  158. static void loc_handle_mousemotion (lglw_int_t *lglw);

  159. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  160. static void loc_touchinput_update (lglw_int_t *lglw);

  161. 

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

  163. 

  164. 

  165. // ---------------------------------------------------------------------------- module vars

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

  167. 

  168. 

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

  170. // ---------------------------------------------------------------------------- lglw_log

  171. static FILE *logfile;

  172. 

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

  174.    fprintf(logfile, logData);

  175.    fflush(logfile);

  176. }

  177. 

  178. 

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

  180. // ---------------------------------------------------------------------------- xerror_log

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

  182.    char error_text[1024];

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

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

  185.    return 0;

  186. }

  187. 

  188. 

  189. // ---------------------------------------------------------------------------- lglw_init

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

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

  192. 

  193.    // TODO: remove/improve

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

  195.    XSetErrorHandler(xerror_handler);

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

  197. 

  198.    if(NULL != lglw)

  199.    {

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

  201. 

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

  203.       if(_w <= 16)

  204.          _w = LGLW_DEFAULT_HIDDEN_W;

  205. 

  206.       if(_h <= 16)

  207.          _h = LGLW_DEFAULT_HIDDEN_H;

  208. 

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

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

  211.       {

  212.          free(lglw);

  213.          lglw = NULL;

  214.       }

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

  216.    }

  217. 

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

  219. 

  220.    return lglw;

  221. }

  222. 

  223. 

  224. // ---------------------------------------------------------------------------- lglw_exit

  225. void lglw_exit(lglw_t _lglw) {

  226.    LGLW(_lglw);

  227. 

  228.    if(NULL != lglw)

  229.    {

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

  231. 

  232.       loc_destroy_hidden_window(lglw);

  233. 

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

  235. 

  236.       fclose(logfile);

  237.       free(lglw);

  238.    }

  239. }

  240. 

  241. 

  242. // ---------------------------------------------------------------------------- lglw_userdata_set

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

  244.    LGLW(_lglw);

  245. 

  246.    if(NULL != lglw)

  247.    {

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

  249.       lglw->user_data = _userData;

  250.    }

  251. }

  252. 

  253. // ---------------------------------------------------------------------------- lglw_userdata_get

  254. void *lglw_userdata_get(lglw_t _lglw) {

  255.    LGLW(_lglw);

  256. 

  257.    if(NULL != lglw)

  258.    {

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

  260.       return lglw->user_data;

  261.    }

  262. 

  263.    return NULL;

  264. }

  265. 

  266. 

  267. // ---------------------------------------------------------------------------- loc_create_hidden_window

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

  269. 

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

  271. 

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

  273.    XSetWindowAttributes swa;

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

  275.    int screen;

  276. 

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

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

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

  280. 

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

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

  283. 

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

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

  286.    {

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

  288.       return LGLW_FALSE;

  289.    }

  290. 

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

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

  293. 

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

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

  296.    {

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

  298.       return LGLW_FALSE;

  299.    }

  300. 

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

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

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

  304. 

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

  306.    swa.border_pixel = 0;

  307.    swa.colormap = lglw->cmap;

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

  309.       0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,

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

  311. 

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

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

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

  315. 

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

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

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

  319. 

  320.    return LGLW_TRUE;

  321. }

  322. 

  323. 

  324. // ---------------------------------------------------------------------------- loc_destroy_hidden_window

  325. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  328.    {

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

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

  331.    }

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

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

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

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

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

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

  338. 

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

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

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

  342. }

  343. 

  344. 

  345. // ---------------------------------------------------------------------------- loc_setEventProc

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

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

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

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

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

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

  352. 

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

  354. void loc_eventProc(void *xevent) {

  355.    lglw_log("XEventProc\n");

  356.    printf("vstgltest<lglw_linux>: XEventProc\n");

  357. }

  358. 

  359. 

  360. #ifdef ARCH_X64

  361. #if 0

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

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

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

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

  366.    size_t data = (size_t)loc_eventProc;

  367.    long temp[2];

  368. 

  369.    printf("vstgltest<lglw_linux>: setEventProc (2*32bit). window=%lu loc_eventProc=%p\n", window, &loc_eventProc);

  370. 

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

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

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

  374. 

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

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

  377.       PropModeReplace, (unsigned char*)temp, 2);

  378. }

  379. #else

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

  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.    //

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

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

  386.    //

  387. 

  388.    // based on mach_override

  389.    static const unsigned char kJumpInstructions[] = {

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

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

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

  393.    };

  394.    static const int kJumpAddress = 6;

  395. 

  396.    static char *ptr = 0;

  397.    if (!ptr) {

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

  399.                          getpagesize()/*PAGE_SIZE*/,

  400.                          PROT_READ | PROT_WRITE | PROT_EXEC,

  401.                          MAP_ANONYMOUS | MAP_PRIVATE | MAP_32BIT,

  402.                          0, 0);

  403.       if (ptr == MAP_FAILED) {

  404.          perror("mmap");

  405.          ptr = 0;

  406.          return;

  407.       } else {

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

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

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

  411.          printf("vstgltest<lglw_linux>: 64bit trampoline installed\n");

  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. }

  419. #endif

  420. #else

  421. // Pulled from the eXT2 example

  422. // TODO: 32-bit support

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

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

  425. 

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

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

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

  429. }

  430. #endif // ARCH_X64

  431. 

  432. 

  433. // ---------------------------------------------------------------------------- lglw_window_open

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

  435.    lglw_bool_t r = LGLW_FALSE;

  436.    LGLW(_lglw);

  437. 

  438.    if(NULL != lglw)

  439.    {

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

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

  442. 

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

  444.       if(_w <= 16)

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

  446. 

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

  448.       if(_h <= 16)

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

  450. 

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

  452. 

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

  454.       XSetWindowAttributes swa;

  455.       XEvent event;

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

  457. 

  458. #if 1

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

  460.       swa.border_pixel = 0;

  461.       swa.colormap = lglw->cmap;

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

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

  464.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  466. 

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

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

  469. 

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

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

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

  473.       if (0 != _parentHWNDOrNull)

  474.       {

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

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

  477.       }

  478.       lglw->win.b_owner = LGLW_TRUE;

  479. #else

  480.       lglw->win.xwnd = (Window)_parentHWNDOrNull;

  481.       lglw->win.b_owner = LGLW_FALSE;

  482. #endif

  483. 

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

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

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

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

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

  489. 

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

  491.       if(lglw->win.b_owner)

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

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

  494.       lglw->win.mapped = LGLW_TRUE;

  495. 

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

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

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

  499. 

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

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

  502. 

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

  504.    }

  505.    return r;

  506. }

  507. 

  508. 

  509. // ---------------------------------------------------------------------------- lglw_window_resize

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

  511.    lglw_bool_t r = LGLW_FALSE;

  512.    LGLW(_lglw);

  513. 

  514.    if(NULL != lglw)

  515.    {

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

  517.       {

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

  519.          r = LGLW_TRUE;

  520. 

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

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

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

  524. 

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

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

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

  528. 

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

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

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

  532. 

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

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

  535.          unsigned int num_children;

  536. 

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

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

  539.             return r;

  540. 

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

  542.          if(children)

  543.             XFree((char *)children);

  544. 

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

  546.          // Resize parent window (if any)

  547.          if(0 != parent)

  548.          {

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

  550.             int x, y;

  551.             unsigned int width, height;

  552.             unsigned int border_width;

  553.             unsigned int depth;

  554. 

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

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

  557.                return r;

  558. 

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

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

  561.          }

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

  563.       }

  564.    }

  565. 

  566.    return r;

  567. }

  568. 

  569. 

  570. // ---------------------------------------------------------------------------- lglw_window_close

  571. void lglw_window_close (lglw_t _lglw) {

  572.    LGLW(_lglw);

  573. 

  574.    if(NULL != lglw)

  575.    {

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

  577.       {

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

  579.          lglw_timer_stop(_lglw);

  580. 

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

  582.          loc_key_unhook(lglw);

  583. 

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

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

  586. 

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

  588.          if(lglw->win.b_owner)

  589.          {

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

  591.             lglw->win.b_owner = LGLW_FALSE;

  592.          }

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

  594.          lglw->win.xwnd = 0;

  595.          lglw->win.mapped = LGLW_FALSE;

  596.       }

  597.    }

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

  599. }

  600. 

  601. 

  602. // ---------------------------------------------------------------------------- lglw_window_show

  603. void lglw_window_show(lglw_t _lglw) {

  604.    LGLW(_lglw);

  605. 

  606.    if(NULL != lglw)

  607.    {

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

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

  610. 

  611.       lglw->win.mapped = LGLW_TRUE;

  612.    }

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

  614. }

  615. 

  616. 

  617. // ---------------------------------------------------------------------------- lglw_window_hide

  618. void lglw_window_hide(lglw_t _lglw) {

  619.    LGLW(_lglw);

  620. 

  621.    if(NULL != lglw)

  622.    {

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

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

  625. 

  626.       lglw->win.mapped = LGLW_FALSE;

  627.    }

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

  629. }

  630. 

  631. 

  632. // ---------------------------------------------------------------------------- lglw_window_is_visible

  633. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  634.    lglw_bool_t r = LGLW_FALSE;

  635.    LGLW(_lglw);

  636. 

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

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

  639.    {

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

  641.       r = lglw->win.mapped;

  642.    }

  643. 

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

  645.    return r;

  646. }

  647. 

  648. 

  649. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  651.    LGLW(_lglw);

  652. 

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

  654.    if(NULL != lglw)

  655.    {

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

  657.       {

  658.          if(NULL != _retX)

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

  660. 

  661.          if(NULL != _retY)

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

  663.       }

  664.    }

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

  666. }

  667. 

  668. 

  669. // ---------------------------------------------------------------------------- lglw_redraw

  670. void lglw_redraw(lglw_t _lglw) {

  671.    LGLW(_lglw);

  672. 

  673.    // (todo) implement me

  674. 

  675.    if(NULL != lglw)

  676.    {

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

  678.       {

  679.          // TODO Event Loop

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

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

  682.          XFlush(lglw->xdsp);

  683.       }

  684.    }

  685. }

  686. 

  687. 

  688. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  690.    LGLW(_lglw);

  691. 

  692.    if(NULL != lglw)

  693.    {

  694.       lglw->redraw.cbk = _cbk;

  695.    }

  696. }

  697. 

  698. 

  699. // ---------------------------------------------------------------------------- lglw_glcontext_push

  700. void lglw_glcontext_push(lglw_t _lglw) {

  701.    LGLW(_lglw);

  702. 

  703.    if(NULL != lglw)

  704.    {

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

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

  707. 

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

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

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

  711.       {

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

  713.       }

  714.    }

  715. }

  716. 

  717. 

  718. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  719. void lglw_glcontext_pop(lglw_t _lglw) {

  720.    LGLW(_lglw);

  721. 

  722.    if(NULL != lglw)

  723.    {

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

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

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

  727.       {

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

  729.       }

  730.    }

  731. }

  732. 

  733. 

  734. // ---------------------------------------------------------------------------- lglw_swap_buffers

  735. void lglw_swap_buffers(lglw_t _lglw) {

  736.    LGLW(_lglw);

  737. 

  738.    if(NULL != lglw)

  739.    {

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

  741.       {

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

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

  744.       }

  745.    }

  746. }

  747. 

  748. 

  749. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  752.    LGLW(_lglw);

  753. 

  754.    if(NULL != lglw)

  755.    {

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

  757.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  759.       if(NULL != glXSwapIntervalEXT)

  760.       {

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

  762.          glXSwapIntervalEXT(_ival);

  763.          lglw->win.swap_interval = _ival;

  764.       }

  765.    }

  766. }

  767. 

  768. 

  769. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  770. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  771.    LGLW(_lglw);

  772.    int32_t r = 0;

  773. 

  774.    if(NULL != lglw)

  775.    {

  776.       r = lglw->win.swap_interval;

  777.    }

  778. 

  779.    return r;

  780. }

  781. 

  782. 

  783. // ---------------------------------------------------------------------------- loc_key_hook

  784. static void loc_key_hook(lglw_int_t *lglw) {

  785.    loc_key_unhook(lglw);

  786. 

  787.    // (todo) implement me

  788. 

  789.    khook_lglw = lglw;

  790. }

  791. 

  792. 

  793. // ---------------------------------------------------------------------------- loc_key_unhook

  794. static void loc_key_unhook(lglw_int_t *lglw) {

  795. 

  796.    // (todo) implement me

  797.    if(khook_lglw == lglw)

  798.       khook_lglw = NULL;

  799. }

  800. 

  801. 

  802. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  803. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  804.    loc_key_unhook(lglw);

  805. 

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

  807. 

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

  809.    {

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

  811.    }

  812. 

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

  814. }

  815. 

  816. 

  817. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  818. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  819.    

  820.    loc_key_hook(lglw);

  821. 

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

  823. 

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

  825.    {

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

  827.    }

  828. 

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

  830. }

  831. 

  832. 

  833. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  835.    if(_bPressed)

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

  837.    else

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

  839. 

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

  841.    {

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

  843.    }

  844. }

  845. 

  846. 

  847. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  848. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  849. 

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

  851.    {

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

  853.    }

  854. }

  855. 

  856. 

  857. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  859.    LGLW(_lglw);

  860. 

  861.    if(NULL != lglw)

  862.    {

  863.       lglw->mouse.cbk = _cbk;

  864.    }

  865. }

  866. 

  867. 

  868. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  870.    LGLW(_lglw);

  871. 

  872.    if(NULL != lglw)

  873.    {

  874.       lglw->focus.cbk = _cbk;

  875.    }

  876. }

  877. 

  878. 

  879. // ---------------------------------------------------------------------------- loc_handle_key

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

  881.    lglw_bool_t r = LGLW_FALSE;

  882. 

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

  884.    {

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

  886.    }

  887. 

  888.    return r;

  889. }

  890. 

  891. 

  892. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  894.    LGLW(_lglw);

  895. 

  896.    if(NULL != lglw)

  897.    {

  898.       lglw->keyboard.cbk = _cbk;

  899.    }

  900. }

  901. 

  902. 

  903. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  904. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  905.    uint32_t r = 0u;

  906.    LGLW(_lglw);

  907. 

  908.    if(NULL != lglw)

  909.    {

  910.       r = lglw->keyboard.kmod_state;

  911.    }

  912. 

  913.    return r;

  914. }

  915. 

  916. 

  917. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  919.    LGLW(_lglw);

  920. 

  921.    // (todo) implement me

  922. 

  923.    if(NULL != lglw)

  924.    {

  925.    }

  926. }

  927. 

  928. 

  929. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  930. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  931.    uint32_t r = 0u;

  932.    LGLW(_lglw);

  933. 

  934.    if(NULL != lglw)

  935.    {

  936.       r = lglw->mouse.button_state;

  937.    }

  938. 

  939.    return r;

  940. }

  941. 

  942. 

  943. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  945.    LGLW(_lglw);

  946. 

  947.    if(NULL != lglw)

  948.    {

  949.       // (todo) implement me

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

  951.       {

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

  953.          {

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

  955.             {

  956.                lglw_mouse_ungrab(_lglw);

  957.             }

  958. 

  959.             switch(_grabMode)

  960.             {

  961.                default:

  962.                case LGLW_MOUSE_GRAB_NONE:

  963.                   break;

  964. 

  965.                case LGLW_MOUSE_GRAB_CAPTURE:

  966.                   // (todo) implement me

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

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

  969.                   break;

  970. 

  971.                case LGLW_MOUSE_GRAB_WARP:

  972.                   // (todo) implement me

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

  974.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  978.                   break;

  979.             }

  980.          }

  981.       }

  982.    }

  983. }

  984. 

  985. 

  986. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  987. void lglw_mouse_ungrab(lglw_t _lglw) {

  988.    LGLW(_lglw);

  989. 

  990.    if(NULL != lglw)

  991.    {

  992.       // (todo) implement me

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

  994.       {

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

  996.          {

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

  998.             {

  999.                default:

  1000.                case LGLW_MOUSE_GRAB_NONE:

  1001.                   break;

  1002. 

  1003.                case LGLW_MOUSE_GRAB_CAPTURE:

  1004.                   // (todo) implement me

  1005.                   // (void)ReleaseCapture();

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

  1007.                   break;

  1008. 

  1009.                case LGLW_MOUSE_GRAB_WARP:

  1010.                   // (todo) implement me

  1011.                   // (void)ReleaseCapture();

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

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

  1014.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  1015.                   break;

  1016.             }

  1017.          }

  1018.       }

  1019.    }

  1020. }

  1021. 

  1022. 

  1023. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  1025.    LGLW(_lglw);

  1026. 

  1027.    // (todo) implement me

  1028. 

  1029.    if(NULL != lglw)

  1030.    {

  1031.    }

  1032. }

  1033. 

  1034. 

  1035. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  1036. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  1038.    {

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

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

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

  1042.    }

  1043. }

  1044. 

  1045. 

  1046. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  1048.    LGLW(_lglw);

  1049. 

  1050.    // (todo) implement me

  1051. 

  1052.    if(NULL != lglw)

  1053.    {

  1054.    }

  1055. }

  1056. 

  1057. 

  1058. // ---------------------------------------------------------------------------- lglw_timer_start

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

  1060.    LGLW(_lglw);

  1061. 

  1062.    // (todo) implement me

  1063. 

  1064.    if(NULL != lglw)

  1065.    {

  1066.    }

  1067. }

  1068. 

  1069. 

  1070. // ---------------------------------------------------------------------------- lglw_timer_stop

  1071. void lglw_timer_stop(lglw_t _lglw) {

  1072.    LGLW(_lglw);

  1073. 

  1074.    // (todo) implement me

  1075. 

  1076.    if(NULL != lglw)

  1077.    {

  1078.    }

  1079. }

  1080. 

  1081. 

  1082. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  1084.    LGLW(_lglw);

  1085. 

  1086.    if(NULL != lglw)

  1087.    {

  1088.       lglw->timer.cbk = _cbk;

  1089.    }

  1090. }

  1091. 

  1092. 

  1093. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  1095. 

  1096.    // (todo) implement me

  1097. }

  1098. 

  1099. 

  1100. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  1102.    LGLW(_lglw);

  1103. 

  1104.    if(NULL != _lglw)

  1105.    {

  1106.       lglw->dropfiles.cbk = _cbk;

  1107. 

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

  1109.    }

  1110. }

  1111. 

  1112. 

  1113. // ---------------------------------------------------------------------------- loc_touchinput_update

  1114. static void loc_touchinput_update(lglw_int_t *lglw) {

  1115. 

  1116.    // (todo) implement me

  1117. }

  1118. 

  1119. 

  1120. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1122.    LGLW(_lglw);

  1123. 

  1124.    if(NULL != _lglw)

  1125.    {

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

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

  1128.    }

  1129. }

  1130. 

  1131. 

  1132. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1133. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1134.    lglw_bool_t r = LGLW_FALSE;

  1135.    LGLW(_lglw);

  1136. 

  1137.    if(NULL != _lglw)

  1138.    {

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

  1140.    }

  1141. 

  1142.    return r;

  1143. }

  1144. 

  1145. 

  1146. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1148.    LGLW(_lglw);

  1149.    (void)_numChars;

  1150. 

  1151.    // (todo) implement me

  1152. 

  1153.    if(NULL != _text)

  1154.    {

  1155.    }

  1156. }

  1157. 

  1158. 

  1159. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1161.    LGLW(_lglw);

  1162. 

  1163.    if(NULL != _retNumChars)

  1164.       *_retNumChars = 0u;

  1165. 

  1166.    if(NULL != _retText)

  1167.       *_retText = 0;

  1168. 

  1169.    if(_maxChars > 0u)

  1170.    {

  1171.       if(NULL != _lglw)

  1172.       {

  1173.          // (todo) implement me

  1174.       }

  1175.    }

  1176. }