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

1056 lines
29KB
Raw Blame History 

  1. /* ----

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

  3.  * ---- author : bsp

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

  5.  * ----

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

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

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

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

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

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

  12.  * ----

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

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

  15.  * ----

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

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

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

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

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

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

  22.  * ---- THE SOFTWARE.

  23.  * ----

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

  25.  * ----

  26.  * ---- created: 04Aug2018

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

  28.  * ----

  29.  * ----

  30.  */

  31. 

  32. #include "lglw.h"

  33. 

  34. #include <stdlib.h>

  35. #include <stdio.h>

  36. #include <string.h>

  37. 

  38. #include <X11/Xlib.h>

  39. #include <X11/Xutil.h>

  40. #include <X11/Xos.h>

  41. 

  42. #include <GL/gl.h>

  43. #include <GL/glx.h>

  44. 

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

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

  47. 

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

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

  50. 

  51. #define LGLW_DEFAULT_HIDDEN_W  (800)

  52. #define LGLW_DEFAULT_HIDDEN_H  (600)

  53. 

  54. #define LGLW_MOUSE_TOUCH_LMB_TIMEOUT   (250u)

  55. #define LGLW_MOUSE_TOUCH_RMB_TIMEOUT   (500u)

  56. #define LGLW_MOUSE_TOUCH_RMB_STATE_IDLE  (0u)

  57. #define LGLW_MOUSE_TOUCH_RMB_STATE_LMB   (1u)

  58. #define LGLW_MOUSE_TOUCH_RMB_STATE_WAIT  (2u)

  59. #define LGLW_MOUSE_TOUCH_RMB_STATE_RMB   (3u)

  60. #define LGLW_MOUSE_TOUCH_RMB_MOVE_THRESHOLD  (7u)

  61. 

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

  63. 

  64. 

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

  66. typedef struct lglw_int_s {

  67.    void        *user_data;    // arbitrary user data

  68.    Display     *xdsp;

  69.    XVisualInfo *vi;

  70.    Colormap     cmap;

  71.    Window       parent_xwnd;  // created by host

  72. 

  73.    struct {

  74.       lglw_vec2i_t size;

  75.       Window       xwnd;

  76.    } hidden;

  77. 

  78.    struct {

  79.       lglw_vec2i_t size;

  80.       Window       xwnd;

  81.       lglw_bool_t  mapped;

  82.       int32_t      swap_interval;

  83.    } win;

  84. 

  85.    GLXContext   ctx;

  86. 

  87.    struct {

  88.       GLXContext   ctx;

  89.       GLXDrawable  drw;

  90.    } prev;

  91. 

  92.    struct {

  93.       uint32_t            kmod_state;  // See LGLW_KMOD_xxx

  94.       lglw_keyboard_fxn_t cbk;

  95.    } keyboard;

  96. 

  97.    struct {

  98.       lglw_vec2i_t     p;  // last seen mouse position

  99.       uint32_t         button_state;

  100.       lglw_mouse_fxn_t cbk;

  101.       struct {

  102.          uint32_t         mode;

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

  104.          lglw_bool_t      b_queue_warp;

  105.          lglw_vec2i_t     last_p;

  106.       } grab;

  107.       struct {

  108.          lglw_bool_t      b_enable;

  109.          lglw_bool_t      b_update_queued;

  110.          lglw_bool_t      b_syn_rmb;

  111.          uint32_t         syn_rmb_hold_state;  // see LGLW_MOUSE_TOUCH_RMB_STATE_xxx

  112.          uint32_t         hold_start_ms;

  113.          lglw_vec2i_t     hold_start_p;

  114.       } touch;

  115.    } mouse;

  116. 

  117.    struct {

  118.       uint32_t         state;

  119.       lglw_focus_fxn_t cbk;

  120.    } focus;

  121. 

  122.    struct {

  123.       lglw_bool_t      b_running;

  124.       lglw_timer_fxn_t cbk;

  125.    } timer;

  126. 

  127.    struct {

  128.       lglw_dropfiles_fxn_t cbk;

  129.    } dropfiles;

  130. 

  131.    struct {

  132.       lglw_redraw_fxn_t cbk;

  133.    } redraw;

  134. 

  135. } lglw_int_t;

  136. 

  137. 

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

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

  140. static void loc_destroy_hidden_window(lglw_int_t *lglw);

  141. 

  142. static void loc_key_hook(lglw_int_t *lglw);

  143. static void loc_key_unhook(lglw_int_t *lglw);

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

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

  146. // static lglw_bool_t loc_touchkeyboard_is_visible (void);

  147. extern lglw_bool_t lglw_int_touchkeyboard_toggle (void);

  148. 

  149. static void loc_handle_mouseleave (lglw_int_t *lglw);

  150. static void loc_handle_mouseenter (lglw_int_t *lglw);

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

  152. static void loc_handle_mousemotion (lglw_int_t *lglw);

  153. static void loc_handle_queued_mouse_warp (lglw_int_t *lglw);

  154. static void loc_touchinput_update (lglw_int_t *lglw);

  155. 

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

  157. 

  158. 

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

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

  161. 

  162. 

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

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

  165. static FILE *logfile;

  166. 

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

  168.    fprintf(logfile, logData);

  169.    fflush(logfile);

  170. }

  171. 

  172. 

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

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

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

  176.    char error_text[1024];

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

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

  179.    return 0;

  180. }

  181. 

  182. 

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

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

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

  186. 

  187.    // TODO: remove/improve

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

  189.    XSetErrorHandler(xerror_handler);

  190. 

  191.    if(NULL != lglw)

  192.    {

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

  194. 

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

  196.       if(_w <= 16)

  197.          _w = LGLW_DEFAULT_HIDDEN_W;

  198. 

  199.       if(_h <= 16)

  200.          _h = LGLW_DEFAULT_HIDDEN_H;

  201. 

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

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

  204.       {

  205.          free(lglw);

  206.          lglw = NULL;

  207.       }

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

  209.    }

  210. 

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

  212. 

  213.    return lglw;

  214. }

  215. 

  216. 

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

  218. void lglw_exit(lglw_t _lglw) {

  219.    LGLW(_lglw);

  220. 

  221.    if(NULL != lglw)

  222.    {

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

  224. 

  225.       loc_destroy_hidden_window(lglw);

  226. 

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

  228. 

  229.       fclose(logfile);

  230.       free(lglw);

  231.    }

  232. }

  233. 

  234. 

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

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

  237.    LGLW(_lglw);

  238. 

  239.    if(NULL != lglw)

  240.    {

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

  242.       lglw->user_data = _userData;

  243.    }

  244. }

  245. 

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

  247. void *lglw_userdata_get(lglw_t _lglw) {

  248.    LGLW(_lglw);

  249. 

  250.    if(NULL != lglw)

  251.    {

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

  253.       return lglw->user_data;

  254.    }

  255. 

  256.    return NULL;

  257. }

  258. 

  259. 

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

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

  262. 

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

  264. 

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

  266.    XSetWindowAttributes swa;

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

  268.    int screen;

  269. 

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

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

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

  273. 

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

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

  276. 

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

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

  279.    {

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

  281.       return LGLW_FALSE;

  282.    }

  283. 

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

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

  286. 

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

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

  289.    {

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

  291.       return LGLW_FALSE;

  292.    }

  293. 

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

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

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

  297. 

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

  299.    swa.border_pixel = 0;

  300.    swa.colormap = lglw->cmap;

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

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

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

  304. 

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

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

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

  308. 

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

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

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

  312. 

  313.    return LGLW_TRUE;

  314. }

  315. 

  316. 

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

  318. static void loc_destroy_hidden_window(lglw_int_t *lglw) {

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

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

  321.    {

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

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

  324.    }

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

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

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

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

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

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

  331. 

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

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

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

  335. }

  336. 

  337. 

  338. // ---------------------------------------------------------------------------- lglw_window_open

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

  340.    lglw_bool_t r = LGLW_FALSE;

  341.    LGLW(_lglw);

  342. 

  343.    if(NULL != lglw)

  344.    {

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

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

  347. 

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

  349.       if(_w <= 16)

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

  351. 

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

  353.       if(_h <= 16)

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

  355. 

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

  357. 

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

  359.       XSetWindowAttributes swa;

  360.       XEvent event;

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

  362. 

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

  364.       swa.border_pixel = 0;

  365.       swa.colormap = lglw->cmap;

  366.       swa.event_mask = EnterWindowMask | LeaveWindowMask;

  367.       lglw->win.xwnd = XCreateWindow(lglw->xdsp, lglw->parent_xwnd,

  368.          0, 0, _w, _h, 0, CopyFromParent, InputOutput,

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

  370. 

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

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

  373. 

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

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

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

  377.       lglw->win.mapped = LGLW_TRUE;

  378. 

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

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

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

  382. 

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

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

  385. 

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

  387.    }

  388.    return r;

  389. }

  390. 

  391. 

  392. // ---------------------------------------------------------------------------- lglw_window_resize

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

  394.    lglw_bool_t r = LGLW_FALSE;

  395.    LGLW(_lglw);

  396. 

  397.    if(NULL != lglw)

  398.    {

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

  400.       {

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

  402.          r = LGLW_TRUE;

  403. 

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

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

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

  407. 

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

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

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

  411. 

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

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

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

  415. 

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

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

  418.          unsigned int num_children;

  419. 

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

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

  422.             return r;

  423. 

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

  425.          if(children)

  426.             XFree((char *)children);

  427. 

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

  429.          // Resize parent window (if any)

  430.          if(0 != parent)

  431.          {

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

  433.             int x, y;

  434.             unsigned int width, height;

  435.             unsigned int border_width;

  436.             unsigned int depth;

  437. 

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

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

  440.                return r;

  441. 

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

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

  444.          }

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

  446.       }

  447.    }

  448. 

  449.    return r;

  450. }

  451. 

  452. 

  453. // ---------------------------------------------------------------------------- lglw_window_close

  454. void lglw_window_close (lglw_t _lglw) {

  455.    LGLW(_lglw);

  456. 

  457.    if(NULL != lglw)

  458.    {

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

  460.       {

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

  462.          lglw_timer_stop(_lglw);

  463. 

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

  465.          loc_key_unhook(lglw);

  466. 

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

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

  469. 

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

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

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

  473.          lglw->win.xwnd = 0;

  474.          lglw->win.mapped = LGLW_FALSE;

  475.       }

  476.    }

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

  478. }

  479. 

  480. 

  481. // ---------------------------------------------------------------------------- lglw_window_show

  482. void lglw_window_show(lglw_t _lglw) {

  483.    LGLW(_lglw);

  484. 

  485.    if(NULL != lglw)

  486.    {

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

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

  489. 

  490.       lglw->win.mapped = LGLW_TRUE;

  491.    }

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

  493. }

  494. 

  495. 

  496. // ---------------------------------------------------------------------------- lglw_window_hide

  497. void lglw_window_hide(lglw_t _lglw) {

  498.    LGLW(_lglw);

  499. 

  500.    if(NULL != lglw)

  501.    {

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

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

  504. 

  505.       lglw->win.mapped = LGLW_FALSE;

  506.    }

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

  508. }

  509. 

  510. 

  511. // ---------------------------------------------------------------------------- lglw_window_is_visible

  512. lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {

  513.    lglw_bool_t r = LGLW_FALSE;

  514.    LGLW(_lglw);

  515. 

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

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

  518.    {

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

  520.       r = lglw->win.mapped;

  521.    }

  522. 

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

  524.    return r;

  525. }

  526. 

  527. 

  528. // ---------------------------------------------------------------------------- lglw_window_size_get

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

  530.    LGLW(_lglw);

  531. 

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

  533.    if(NULL != lglw)

  534.    {

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

  536.       {

  537.          if(NULL != _retX)

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

  539. 

  540.          if(NULL != _retY)

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

  542.       }

  543.    }

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

  545. }

  546. 

  547. 

  548. // ---------------------------------------------------------------------------- lglw_redraw

  549. void lglw_redraw(lglw_t _lglw) {

  550.    LGLW(_lglw);

  551. 

  552.    // (todo) implement me

  553. 

  554.    if(NULL != lglw)

  555.    {

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

  557.       {

  558.          // TODO Event Loop

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

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

  561.          XFlush(lglw->xdsp);

  562.       }

  563.    }

  564. }

  565. 

  566. 

  567. // ---------------------------------------------------------------------------- lglw_redraw_callback_set

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

  569.    LGLW(_lglw);

  570. 

  571.    if(NULL != lglw)

  572.    {

  573.       lglw->redraw.cbk = _cbk;

  574.    }

  575. }

  576. 

  577. 

  578. // ---------------------------------------------------------------------------- lglw_glcontext_push

  579. void lglw_glcontext_push(lglw_t _lglw) {

  580.    LGLW(_lglw);

  581. 

  582.    if(NULL != lglw)

  583.    {

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

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

  586. 

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

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

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

  590.       {

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

  592.       }

  593.    }

  594. }

  595. 

  596. 

  597. // ---------------------------------------------------------------------------- lglw_glcontext_pop

  598. void lglw_glcontext_pop(lglw_t _lglw) {

  599.    LGLW(_lglw);

  600. 

  601.    if(NULL != lglw)

  602.    {

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

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

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

  606.       {

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

  608.       }

  609.    }

  610. }

  611. 

  612. 

  613. // ---------------------------------------------------------------------------- lglw_swap_buffers

  614. void lglw_swap_buffers(lglw_t _lglw) {

  615.    LGLW(_lglw);

  616. 

  617.    if(NULL != lglw)

  618.    {

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

  620.       {

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

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

  623.       }

  624.    }

  625. }

  626. 

  627. 

  628. // ---------------------------------------------------------------------------- lglw_swap_interval_set

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

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

  631.    LGLW(_lglw);

  632. 

  633.    if(NULL != lglw)

  634.    {

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

  636.       PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;

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

  638.       if(NULL != glXSwapIntervalEXT)

  639.       {

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

  641.          glXSwapIntervalEXT(_ival);

  642.          lglw->win.swap_interval = _ival;

  643.       }

  644.    }

  645. }

  646. 

  647. 

  648. // ---------------------------------------------------------------------------- lglw_swap_interval_get

  649. int32_t lglw_swap_interval_get(lglw_t _lglw) {

  650.    LGLW(_lglw);

  651.    int32_t r = 0;

  652. 

  653.    if(NULL != lglw)

  654.    {

  655.       r = lglw->win.swap_interval;

  656.    }

  657. 

  658.    return r;

  659. }

  660. 

  661. 

  662. // ---------------------------------------------------------------------------- loc_key_hook

  663. static void loc_key_hook(lglw_int_t *lglw) {

  664.    loc_key_unhook(lglw);

  665. 

  666.    // (todo) implement me

  667. 

  668.    khook_lglw = lglw;

  669. }

  670. 

  671. 

  672. // ---------------------------------------------------------------------------- loc_key_unhook

  673. static void loc_key_unhook(lglw_int_t *lglw) {

  674. 

  675.    // (todo) implement me

  676.    if(khook_lglw == lglw)

  677.       khook_lglw = NULL;

  678. }

  679. 

  680. 

  681. // ---------------------------------------------------------------------------- loc_handle_mouseleave

  682. static void loc_handle_mouseleave(lglw_int_t *lglw) {

  683.    loc_key_unhook(lglw);

  684. 

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

  686. 

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

  688.    {

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

  690.    }

  691. 

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

  693. }

  694. 

  695. 

  696. // ---------------------------------------------------------------------------- loc_handle_mouseenter

  697. static void loc_handle_mouseenter(lglw_int_t *lglw) {

  698.    

  699.    loc_key_hook(lglw);

  700. 

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

  702. 

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

  704.    {

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

  706.    }

  707. 

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

  709. }

  710. 

  711. 

  712. // ---------------------------------------------------------------------------- loc_handle_mousebutton

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

  714.    if(_bPressed)

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

  716.    else

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

  718. 

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

  720.    {

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

  722.    }

  723. }

  724. 

  725. 

  726. // ---------------------------------------------------------------------------- loc_handle_mousemotion

  727. static void loc_handle_mousemotion(lglw_int_t *lglw) {

  728. 

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

  730.    {

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

  732.    }

  733. }

  734. 

  735. 

  736. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  738.    LGLW(_lglw);

  739. 

  740.    if(NULL != lglw)

  741.    {

  742.       lglw->mouse.cbk = _cbk;

  743.    }

  744. }

  745. 

  746. 

  747. // ---------------------------------------------------------------------------- lglw_mouse_callback_set

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

  749.    LGLW(_lglw);

  750. 

  751.    if(NULL != lglw)

  752.    {

  753.       lglw->focus.cbk = _cbk;

  754.    }

  755. }

  756. 

  757. 

  758. // ---------------------------------------------------------------------------- loc_handle_key

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

  760.    lglw_bool_t r = LGLW_FALSE;

  761. 

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

  763.    {

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

  765.    }

  766. 

  767.    return r;

  768. }

  769. 

  770. 

  771. // ---------------------------------------------------------------------------- lglw_keyboard_callback_set

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

  773.    LGLW(_lglw);

  774. 

  775.    if(NULL != lglw)

  776.    {

  777.       lglw->keyboard.cbk = _cbk;

  778.    }

  779. }

  780. 

  781. 

  782. // ---------------------------------------------------------------------------- lglw_keyboard_get_modifiers

  783. uint32_t lglw_keyboard_get_modifiers(lglw_t _lglw) {

  784.    uint32_t r = 0u;

  785.    LGLW(_lglw);

  786. 

  787.    if(NULL != lglw)

  788.    {

  789.       r = lglw->keyboard.kmod_state;

  790.    }

  791. 

  792.    return r;

  793. }

  794. 

  795. 

  796. // ---------------------------------------------------------------------------- lglw_touchkeyboard_show

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

  798.    LGLW(_lglw);

  799. 

  800.    // (todo) implement me

  801. 

  802.    if(NULL != lglw)

  803.    {

  804.    }

  805. }

  806. 

  807. 

  808. // ---------------------------------------------------------------------------- lglw_mouse_get_buttons

  809. uint32_t lglw_mouse_get_buttons(lglw_t _lglw) {

  810.    uint32_t r = 0u;

  811.    LGLW(_lglw);

  812. 

  813.    if(NULL != lglw)

  814.    {

  815.       r = lglw->mouse.button_state;

  816.    }

  817. 

  818.    return r;

  819. }

  820. 

  821. 

  822. // ---------------------------------------------------------------------------- lglw_mouse_grab

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

  824.    LGLW(_lglw);

  825. 

  826.    if(NULL != lglw)

  827.    {

  828.       // (todo) implement me

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

  830.       {

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

  832.          {

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

  834.             {

  835.                lglw_mouse_ungrab(_lglw);

  836.             }

  837. 

  838.             switch(_grabMode)

  839.             {

  840.                default:

  841.                case LGLW_MOUSE_GRAB_NONE:

  842.                   break;

  843. 

  844.                case LGLW_MOUSE_GRAB_CAPTURE:

  845.                   // (todo) implement me

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

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

  848.                   break;

  849. 

  850.                case LGLW_MOUSE_GRAB_WARP:

  851.                   // (todo) implement me

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

  853.                   lglw_mouse_cursor_show(_lglw, LGLW_FALSE);

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

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

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

  857.                   break;

  858.             }

  859.          }

  860.       }

  861.    }

  862. }

  863. 

  864. 

  865. // ---------------------------------------------------------------------------- lglw_mouse_ungrab

  866. void lglw_mouse_ungrab(lglw_t _lglw) {

  867.    LGLW(_lglw);

  868. 

  869.    if(NULL != lglw)

  870.    {

  871.       // (todo) implement me

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

  873.       {

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

  875.          {

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

  877.             {

  878.                default:

  879.                case LGLW_MOUSE_GRAB_NONE:

  880.                   break;

  881. 

  882.                case LGLW_MOUSE_GRAB_CAPTURE:

  883.                   // (todo) implement me

  884.                   // (void)ReleaseCapture();

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

  886.                   break;

  887. 

  888.                case LGLW_MOUSE_GRAB_WARP:

  889.                   // (todo) implement me

  890.                   // (void)ReleaseCapture();

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

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

  893.                   lglw_mouse_cursor_show(_lglw, LGLW_TRUE);

  894.                   break;

  895.             }

  896.          }

  897.       }

  898.    }

  899. }

  900. 

  901. 

  902. // ---------------------------------------------------------------------------- lglw_mouse_warp

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

  904.    LGLW(_lglw);

  905. 

  906.    // (todo) implement me

  907. 

  908.    if(NULL != lglw)

  909.    {

  910.    }

  911. }

  912. 

  913. 

  914. // ---------------------------------------------------------------------------- loc_handle_queued_mouse_warp

  915. static void loc_handle_queued_mouse_warp(lglw_int_t *lglw) {

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

  917.    {

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

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

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

  921.    }

  922. }

  923. 

  924. 

  925. // ---------------------------------------------------------------------------- lglw_mouse_cursor_show

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

  927.    LGLW(_lglw);

  928. 

  929.    // (todo) implement me

  930. 

  931.    if(NULL != lglw)

  932.    {

  933.    }

  934. }

  935. 

  936. 

  937. // ---------------------------------------------------------------------------- lglw_timer_start

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

  939.    LGLW(_lglw);

  940. 

  941.    // (todo) implement me

  942. 

  943.    if(NULL != lglw)

  944.    {

  945.    }

  946. }

  947. 

  948. 

  949. // ---------------------------------------------------------------------------- lglw_timer_stop

  950. void lglw_timer_stop(lglw_t _lglw) {

  951.    LGLW(_lglw);

  952. 

  953.    // (todo) implement me

  954. 

  955.    if(NULL != lglw)

  956.    {

  957.    }

  958. }

  959. 

  960. 

  961. // ---------------------------------------------------------------------------- lglw_timer_callback_set

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

  963.    LGLW(_lglw);

  964. 

  965.    if(NULL != lglw)

  966.    {

  967.       lglw->timer.cbk = _cbk;

  968.    }

  969. }

  970. 

  971. 

  972. // ---------------------------------------------------------------------------- loc_enable_dropfiles

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

  974. 

  975.    // (todo) implement me

  976. }

  977. 

  978. 

  979. // ---------------------------------------------------------------------------- lglw_dropfiles_callback_set

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

  981.    LGLW(_lglw);

  982. 

  983.    if(NULL != _lglw)

  984.    {

  985.       lglw->dropfiles.cbk = _cbk;

  986. 

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

  988.    }

  989. }

  990. 

  991. 

  992. // ---------------------------------------------------------------------------- loc_touchinput_update

  993. static void loc_touchinput_update(lglw_int_t *lglw) {

  994. 

  995.    // (todo) implement me

  996. }

  997. 

  998. 

  999. // ---------------------------------------------------------------------------- lglw_touchinput_set

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

  1001.    LGLW(_lglw);

  1002. 

  1003.    if(NULL != _lglw)

  1004.    {

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

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

  1007.    }

  1008. }

  1009. 

  1010. 

  1011. // ---------------------------------------------------------------------------- lglw_touchinput_get

  1012. lglw_bool_t lglw_touchinput_get(lglw_t _lglw) {

  1013.    lglw_bool_t r = LGLW_FALSE;

  1014.    LGLW(_lglw);

  1015. 

  1016.    if(NULL != _lglw)

  1017.    {

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

  1019.    }

  1020. 

  1021.    return r;

  1022. }

  1023. 

  1024. 

  1025. // ---------------------------------------------------------------------------- lglw_clipboard_text_set

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

  1027.    LGLW(_lglw);

  1028.    (void)_numChars;

  1029. 

  1030.    // (todo) implement me

  1031. 

  1032.    if(NULL != _text)

  1033.    {

  1034.    }

  1035. }

  1036. 

  1037. 

  1038. // ---------------------------------------------------------------------------- lglw_clipboard_text_get

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

  1040.    LGLW(_lglw);

  1041. 

  1042.    if(NULL != _retNumChars)

  1043.       *_retNumChars = 0u;

  1044. 

  1045.    if(NULL != _retText)

  1046.       *_retText = 0;

  1047. 

  1048.    if(_maxChars > 0u)

  1049.    {

  1050.       if(NULL != _lglw)

  1051.       {

  1052.          // (todo) implement me

  1053.       }

  1054.    }

  1055. }