VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
Browse Source

add Dlog*() macros (4 verbosity levels)

pull/1639/head
bsp2 6 years ago
parent
d33071e5e2
commit
30cc445cde
1 changed files with 177 additions and 157 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +177
    -157
      dep/lglw/lglw_linux.c

+ 177
- 157
dep/lglw/lglw_linux.c View File

@@ -47,15 +47,41 @@
#include <unistd.h> #include <unistd.h>
#endif // ARCH_X64 #endif // ARCH_X64


//
// Regular log entry (low frequency)
//
// #define Dlog_verbose if(1);else lglw_log
#define Dlog if(0);else lglw_log

//
// Verbose log entry
//
// #define Dlog_v if(1);else lglw_log
#define Dlog_v if(0);else lglw_log

//
// Very-verbose log entry
//
// #define Dlog_vv if(1);else lglw_log
#define Dlog_vv if(0);else lglw_log

//
// Very-very-verbose log entry
//
#define Dlog_vvv if(1);else lglw_log
// #define Dlog_vvv if(0);else lglw_log

//
// Print to stdout
//
// Please use the Dlog* macros instead!
//
#define Dprintf if(0);else printf #define Dprintf if(0);else printf
// #define Dprintf if(1);else printf // #define Dprintf if(1);else printf


#define Dprintf_verbose if(1);else printf #define Dprintf_verbose if(1);else printf
// #define Dprintf_verbose if(0);else printf // #define Dprintf_verbose if(0);else printf


#define Dlog_verbose if(1);else lglw_log
// #define Dlog_verbose if(0);else lglw_log

// ---------------------------------------------------------------------------- macros and defines // ---------------------------------------------------------------------------- macros and defines
#define LGLW(a) lglw_int_t *lglw = ((lglw_int_t*)(a)) #define LGLW(a) lglw_int_t *lglw = ((lglw_int_t*)(a))


@@ -212,7 +238,7 @@ void lglw_log(const char *logData, ...) {
static int xerror_handler(Display *display, XErrorEvent *error) { static int xerror_handler(Display *display, XErrorEvent *error) {
char error_text[1024]; char error_text[1024];
XGetErrorText(display, error->error_code, error_text, 1024); XGetErrorText(display, error->error_code, error_text, 1024);
lglw_log("XERROR (%d): %s, %d, %d\n", error->error_code, error_text, error->request_code, error->minor_code);
Dlog("XERROR (%d): %s, %d, %d\n", error->error_code, error_text, error->request_code, error->minor_code);
return 0; return 0;
} }


@@ -221,7 +247,7 @@ static int xerror_handler(Display *display, XErrorEvent *error) {
lglw_t lglw_init(int32_t _w, int32_t _h) { lglw_t lglw_init(int32_t _w, int32_t _h) {
lglw_int_t *lglw = malloc(sizeof(lglw_int_t)); lglw_int_t *lglw = malloc(sizeof(lglw_int_t));


printf("xxx lglw_init: sizeof(uint32_t)=%lu sizeof(long)=%lu sizeof(void*)=%lu\n", sizeof(uint32_t), sizeof(long), sizeof(void*));
Dprintf("xxx lglw_init: sizeof(uint32_t)=%lu sizeof(long)=%lu sizeof(void*)=%lu\n", sizeof(uint32_t), sizeof(long), sizeof(void*));


// TODO: remove/improve // TODO: remove/improve
logfile = fopen("/tmp/lglw_log.txt", "w"); logfile = fopen("/tmp/lglw_log.txt", "w");
@@ -234,23 +260,23 @@ lglw_t lglw_init(int32_t _w, int32_t _h) {
{ {
memset(lglw, 0, sizeof(lglw_int_t)); memset(lglw, 0, sizeof(lglw_int_t));


lglw_log("lglw:lglw_init: 1\n");
Dlog("lglw:lglw_init: 1\n");
if(_w <= 16) if(_w <= 16)
_w = LGLW_DEFAULT_HIDDEN_W; _w = LGLW_DEFAULT_HIDDEN_W;


if(_h <= 16) if(_h <= 16)
_h = LGLW_DEFAULT_HIDDEN_H; _h = LGLW_DEFAULT_HIDDEN_H;


lglw_log("lglw:lglw_init: 2\n");
Dlog("lglw:lglw_init: 2\n");
if(!loc_create_hidden_window(lglw, _w, _h)) if(!loc_create_hidden_window(lglw, _w, _h))
{ {
free(lglw); free(lglw);
lglw = NULL; lglw = NULL;
} }
lglw_log("lglw:lglw_init: 3\n");
Dlog("lglw:lglw_init: 3\n");
} }


lglw_log("lglw:lglw_init: EXIT\n");
Dlog("lglw:lglw_init: EXIT\n");


return lglw; return lglw;
} }
@@ -262,11 +288,11 @@ void lglw_exit(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("lglw:lglw_exit: 1\n");
Dlog("lglw:lglw_exit: 1\n");


loc_destroy_hidden_window(lglw); loc_destroy_hidden_window(lglw);


lglw_log("lglw:lglw_exit: 2\n");
Dlog("lglw:lglw_exit: 2\n");


fclose(logfile); fclose(logfile);
free(lglw); free(lglw);
@@ -280,7 +306,7 @@ void lglw_userdata_set(lglw_t _lglw, void *_userData) {


if(NULL != lglw) if(NULL != lglw)
{ {
// lglw_log("lglw:lglw_userdata_set: 1\n");
Dlog_vvv("lglw:lglw_userdata_set: ptr=%p\n", _userData);
lglw->user_data = _userData; lglw->user_data = _userData;
} }
} }
@@ -291,7 +317,7 @@ void *lglw_userdata_get(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
// lglw_log("lglw:lglw_userdata_get: 1\n");
Dlog_vvv("lglw:lglw_userdata_get: return ptr=%p\n", lglw->user_data);
return lglw->user_data; return lglw->user_data;
} }


@@ -304,51 +330,51 @@ static lglw_bool_t loc_create_hidden_window(lglw_int_t *lglw, int32_t _w, int32_


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


lglw_log("lglw:loc_create_hidden_window: 1\n");
Dlog_v("lglw:loc_create_hidden_window: 1\n");
XSetWindowAttributes swa; XSetWindowAttributes swa;
int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, None }; int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, None };
int screen; int screen;


lglw_log("lglw:loc_create_hidden_window: 2\n");
Dlog_v("lglw:loc_create_hidden_window: 2\n");
lglw->xdsp = XOpenDisplay(NULL); lglw->xdsp = XOpenDisplay(NULL);
screen = DefaultScreen(lglw->xdsp); screen = DefaultScreen(lglw->xdsp);


lglw_log("lglw:loc_create_hidden_window: 3\n");
Dlog_v("lglw:loc_create_hidden_window: 3\n");
lglw->vi = glXChooseVisual(lglw->xdsp, screen, attrib); lglw->vi = glXChooseVisual(lglw->xdsp, screen, attrib);


lglw_log("lglw:loc_create_hidden_window: 4\n");
Dlog_v("lglw:loc_create_hidden_window: 4\n");
if(NULL == lglw->vi) if(NULL == lglw->vi)
{ {
lglw_log("[---] lglw: failed to find GLX Visual for hidden window\n");
Dlog("[---] lglw: failed to find GLX Visual for hidden window\n");
return LGLW_FALSE; return LGLW_FALSE;
} }


lglw_log("lglw:loc_create_hidden_window: 5\n");
Dlog_v("lglw:loc_create_hidden_window: 5\n");
lglw->ctx = glXCreateContext(lglw->xdsp, lglw->vi, None, True); lglw->ctx = glXCreateContext(lglw->xdsp, lglw->vi, None, True);


lglw_log("lglw:loc_create_hidden_window: 6\n");
Dlog_v("lglw:loc_create_hidden_window: 6\n");
if(NULL == lglw->ctx) if(NULL == lglw->ctx)
{ {
lglw_log("[---] lglw: failed to create GLX Context for hidden window\n");
Dlog("[---] lglw: failed to create GLX Context for hidden window\n");
return LGLW_FALSE; return LGLW_FALSE;
} }


lglw_log("lglw:loc_create_hidden_window: 7\n");
Dlog_v("lglw:loc_create_hidden_window: 7\n");
lglw->cmap = XCreateColormap(lglw->xdsp, RootWindow(lglw->xdsp, lglw->vi->screen), lglw->cmap = XCreateColormap(lglw->xdsp, RootWindow(lglw->xdsp, lglw->vi->screen),
lglw->vi->visual, AllocNone); lglw->vi->visual, AllocNone);


lglw_log("lglw:loc_create_hidden_window: 8\n");
Dlog_v("lglw:loc_create_hidden_window: 8\n");
swa.border_pixel = 0; swa.border_pixel = 0;
swa.colormap = lglw->cmap; swa.colormap = lglw->cmap;
lglw->hidden.xwnd = XCreateWindow(lglw->xdsp, DefaultRootWindow(lglw->xdsp), lglw->hidden.xwnd = XCreateWindow(lglw->xdsp, DefaultRootWindow(lglw->xdsp),
0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,
lglw->vi->visual, CWBorderPixel | CWColormap, &swa);
0, 0, LGLW_DEFAULT_HIDDEN_W, LGLW_DEFAULT_HIDDEN_H, 0, CopyFromParent, InputOutput,
lglw->vi->visual, CWBorderPixel | CWColormap, &swa);


lglw_log("lglw:loc_create_hidden_window: 9\n");
Dlog_v("lglw:loc_create_hidden_window: 9\n");
XSetStandardProperties(lglw->xdsp, lglw->hidden.xwnd, "LGLW_hidden", "LGLW_hidden", None, NULL, 0, NULL); XSetStandardProperties(lglw->xdsp, lglw->hidden.xwnd, "LGLW_hidden", "LGLW_hidden", None, NULL, 0, NULL);
XSync(lglw->xdsp, False); XSync(lglw->xdsp, False);


lglw_log("lglw:loc_create_hidden_window: EXIT\n");
Dlog_v("lglw:loc_create_hidden_window: EXIT\n");
lglw->hidden.size.x = _w; lglw->hidden.size.x = _w;
lglw->hidden.size.y = _h; lglw->hidden.size.y = _h;


@@ -358,20 +384,20 @@ static lglw_bool_t loc_create_hidden_window(lglw_int_t *lglw, int32_t _w, int32_


// ---------------------------------------------------------------------------- loc_destroy_hidden_window // ---------------------------------------------------------------------------- loc_destroy_hidden_window
static void loc_destroy_hidden_window(lglw_int_t *lglw) { static void loc_destroy_hidden_window(lglw_int_t *lglw) {
lglw_log("lglw:loc_destroy_hidden_window: 1\n");
Dlog_v("lglw:loc_destroy_hidden_window: 1\n");
if(NULL != lglw->xdsp && NULL != lglw->ctx) if(NULL != lglw->xdsp && NULL != lglw->ctx)
{ {
glXMakeCurrent(lglw->xdsp, None, NULL); glXMakeCurrent(lglw->xdsp, None, NULL);
glXDestroyContext(lglw->xdsp, lglw->ctx); glXDestroyContext(lglw->xdsp, lglw->ctx);
} }
lglw_log("lglw:loc_destroy_hidden_window: 2\n");
Dlog_v("lglw:loc_destroy_hidden_window: 2\n");
if(NULL != lglw->xdsp && 0 != lglw->hidden.xwnd) XDestroyWindow(lglw->xdsp, lglw->hidden.xwnd); if(NULL != lglw->xdsp && 0 != lglw->hidden.xwnd) XDestroyWindow(lglw->xdsp, lglw->hidden.xwnd);
lglw_log("lglw:loc_destroy_hidden_window: 3\n");
Dlog_v("lglw:loc_destroy_hidden_window: 3\n");
if(NULL != lglw->xdsp && 0 != lglw->cmap) XFreeColormap(lglw->xdsp, lglw->cmap); if(NULL != lglw->xdsp && 0 != lglw->cmap) XFreeColormap(lglw->xdsp, lglw->cmap);
lglw_log("lglw:loc_destroy_hidden_window: 4\n");
Dlog_v("lglw:loc_destroy_hidden_window: 4\n");
if(NULL != lglw->vi) XFree(lglw->vi); if(NULL != lglw->vi) XFree(lglw->vi);


lglw_log("lglw:loc_destroy_hidden_window: 5\n");
Dlog_v("lglw:loc_destroy_hidden_window: 5\n");
XSync(lglw->xdsp, False); XSync(lglw->xdsp, False);
if(NULL != lglw->xdsp) XCloseDisplay(lglw->xdsp); if(NULL != lglw->xdsp) XCloseDisplay(lglw->xdsp);
} }
@@ -388,7 +414,7 @@ static void loc_destroy_hidden_window(lglw_int_t *lglw) {
// Very simple function to test _XEventProc is properly called // Very simple function to test _XEventProc is properly called
static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) { static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {


Dlog_verbose("vstgltest<lglw_linux>: eventProc: type=%d serial=%lu send_event=%d lglw=%p\n", xev->xany.type, xev->xany.serial, xev->xany.send_event, lglw);
Dlog_vvv("lglw:loc_eventProc: type=%d serial=%lu send_event=%d lglw=%p\n", xev->xany.type, xev->xany.serial, xev->xany.send_event, lglw);


loc_process_timer(lglw); loc_process_timer(lglw);


@@ -399,12 +425,12 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
switch(xev->type) switch(xev->type)
{ {
default: default:
printf("vstgltest<lglw_linux>: unhandled X11 event type=%d\n", xev->type);
Dlog("lglw:loc_eventProc: unhandled X11 event type=%d\n", xev->type);
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
break; break;


case Expose: case Expose:
Dlog_verbose("vstgltest<lglw_linux>: xev Expose\n");
Dlog_v("lglw:loc_eventProc: xev Expose\n");
loc_handle_queued_mouse_warp(lglw); loc_handle_queued_mouse_warp(lglw);
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
if(NULL != lglw->redraw.cbk) if(NULL != lglw->redraw.cbk)
@@ -417,20 +443,20 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
// TODO: Should FocusIn/Out be treated like WM_CAPTURECHANGED and reset the grab state? // TODO: Should FocusIn/Out be treated like WM_CAPTURECHANGED and reset the grab state?


case FocusIn: case FocusIn:
Dlog_verbose("vstgltest<lglw_linux>: xev FocusIn\n");
Dlog_v("lglw:loc_eventProc: xev FocusIn\n");
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
break; break;


case FocusOut: case FocusOut:
Dlog_verbose("vstgltest<lglw_linux>: xev FocusOut\n");
Dlog_v("lglw:loc_eventProc: xev FocusOut\n");
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
break; break;


case EnterNotify: case EnterNotify:
// printf("vstgltest<lglw_linux>: xev XEnterWindowEvent\n");
// Dlog_v("lglw:loc_eventProc: xev XEnterWindowEvent\n");
; // empty statement ; // empty statement
XEnterWindowEvent *wenter = (XEnterWindowEvent*)xev; XEnterWindowEvent *wenter = (XEnterWindowEvent*)xev;
printf("vstgltest<lglw_linux>: xev EnterNotify: mode:%i, detail:%i, state:%d\n", wenter->mode, wenter->detail, wenter->state);
Dlog_v("lglw:loc_eventProc: xev EnterNotify: mode:%i, detail:%i, state:%d\n", wenter->mode, wenter->detail, wenter->state);
lglw->mouse.p.x = wenter->x; lglw->mouse.p.x = wenter->x;
lglw->mouse.p.y = wenter->y; lglw->mouse.p.y = wenter->y;
loc_handle_mousemotion(lglw); loc_handle_mousemotion(lglw);
@@ -447,10 +473,10 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case LeaveNotify: case LeaveNotify:
// printf("vstgltest<lglw_linux>: xev XLeaveWindowEvent\n");
// Dlog_v("lglw:loc_eventProc: xev XLeaveWindowEvent\n");
; // empty statement ; // empty statement
XLeaveWindowEvent *wexit = (XLeaveWindowEvent*)xev; XLeaveWindowEvent *wexit = (XLeaveWindowEvent*)xev;
printf("vstgltest<lglw_linux>: xev LeaveNotify: mode:%i, detail:%i, state:%d\n", wexit->mode, wexit->detail, wexit->state);
Dlog_v("lglw:loc_eventProc: xev LeaveNotify: mode:%i, detail:%i, state:%d\n", wexit->mode, wexit->detail, wexit->state);


// LeaveNotify messages can be pseudo-motion events (NotifyGrab, NotifyUngrab) // LeaveNotify messages can be pseudo-motion events (NotifyGrab, NotifyUngrab)
// when buttons are pressed, which would trigger false focus changes // when buttons are pressed, which would trigger false focus changes
@@ -464,7 +490,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case MotionNotify: case MotionNotify:
// printf("vstgltest<lglw_linux>: xev MotionNotify\n");
Dlog_v("lglw:loc_eventProc: xev MotionNotify\n");
; // empty statement ; // empty statement
XMotionEvent *motion = (XMotionEvent*)xev; XMotionEvent *motion = (XMotionEvent*)xev;


@@ -490,7 +516,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case KeyPress: case KeyPress:
printf("vstgltest<lglw_linux>: xev KeyPress\n");
Dlog("lglw:loc_eventProc: xev KeyPress\n");
XKeyPressedEvent *keyPress = (XKeyPressedEvent*)xev; XKeyPressedEvent *keyPress = (XKeyPressedEvent*)xev;


eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
@@ -498,7 +524,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
switch(xkp) switch(xkp)
{ {
default: default:
printf("vstgltest<lglw_linux>: xev KeyPress: %x or %lu\n", keyPress->keycode, xkp);
Dlog("lglw:loc_eventProc: xev KeyPress: %x or %lu\n", keyPress->keycode, xkp);
if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT)) if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT))
{ {
KeySym xkpl; KeySym xkpl;
@@ -513,7 +539,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case NoSymbol: case NoSymbol:
printf("vstgltest<lglw_linux>: xev UNKNOWN KeyPress: %x\n", keyPress->keycode);
Dlog("lglw:loc_eventProc: xev UNKNOWN KeyPress: %x\n", keyPress->keycode);
break; break;


case XK_Left: case XK_Left:
@@ -640,7 +666,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case KeyRelease: case KeyRelease:
printf("vstgltest<lglw_linux>: xev KeyRelease\n");
Dlog("lglw:loc_eventProc: xev KeyRelease\n");
XKeyReleasedEvent *keyRelease = (XKeyReleasedEvent*)xev; XKeyReleasedEvent *keyRelease = (XKeyReleasedEvent*)xev;


eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
@@ -648,7 +674,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
switch(xkr) switch(xkr)
{ {
default: default:
printf("vstgltest<lglw_linux>: xev KeyRelease: %x or %lu\n", keyRelease->keycode, xkr);
Dlog("lglw:loc_eventProc: xev KeyRelease: %x or %lu\n", keyRelease->keycode, xkr);
if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT)) if(0u != (lglw->keyboard.kmod_state & LGLW_KMOD_SHIFT))
{ {
KeySym xkrl; KeySym xkrl;
@@ -663,7 +689,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case NoSymbol: case NoSymbol:
printf("vstgltest<lglw_linux>: xev UNKNOWN KeyRelease: %x\n", keyRelease->keycode);
Dlog("lglw:loc_eventProc: xev UNKNOWN KeyRelease: %x\n", keyRelease->keycode);
break; break;


case XK_Left: case XK_Left:
@@ -790,7 +816,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case ButtonPress: case ButtonPress:
printf("vstgltest<lglw_linux>: xev ButtonPress\n");
Dlog("lglw:loc_eventProc: xev ButtonPress\n");
XButtonPressedEvent *btnPress = (XButtonPressedEvent*)xev; XButtonPressedEvent *btnPress = (XButtonPressedEvent*)xev;
lglw->mouse.p.x = btnPress->x; lglw->mouse.p.x = btnPress->x;
lglw->mouse.p.y = btnPress->y; lglw->mouse.p.y = btnPress->y;
@@ -803,7 +829,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
switch(btnPress->button) switch(btnPress->button)
{ {
default: default:
printf("vstgltest<lglw_linux>: xev ButtonPress unhandled button: %i\n", btnPress->button);
Dlog("lglw:loc_eventProc: xev ButtonPress unhandled button: %i\n", btnPress->button);
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
break; break;
case Button1: case Button1:
@@ -830,14 +856,14 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case ButtonRelease: case ButtonRelease:
printf("vstgltest<lglw_linux>: xev ButtonRelease\n");
Dlog("lglw:loc_eventProc: xev ButtonRelease\n");
XButtonReleasedEvent *btnRelease = (XButtonReleasedEvent*)xev; XButtonReleasedEvent *btnRelease = (XButtonReleasedEvent*)xev;
lglw->mouse.p.x = btnRelease->x; lglw->mouse.p.x = btnRelease->x;
lglw->mouse.p.y = btnRelease->y; lglw->mouse.p.y = btnRelease->y;
switch(btnRelease->button) switch(btnRelease->button)
{ {
default: default:
printf("vstgltest<lglw_linux>: xev ButtonRelease unhandled button: %i\n", btnRelease->button);
Dlog("lglw:loc_eventProc: xev ButtonRelease unhandled button: %i\n", btnRelease->button);
eventHandled = LGLW_FALSE; eventHandled = LGLW_FALSE;
break; break;
case Button1: case Button1:
@@ -864,14 +890,14 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
break; break;


case SelectionClear: case SelectionClear:
printf("vstgltest<lglw_linux>: xev SelectionClear\n");
Dlog("lglw:loc_eventProc: xev SelectionClear\n");
lglw->clipboard.numChars = 0; lglw->clipboard.numChars = 0;
free(lglw->clipboard.data); free(lglw->clipboard.data);
eventHandled = LGLW_TRUE; eventHandled = LGLW_TRUE;
break; break;


case SelectionRequest: case SelectionRequest:
printf("vstgltest<lglw_linux>: xev SelectionRequest\n");
Dlog("lglw:loc_eventProc: xev SelectionRequest\n");
XSelectionRequestEvent *cbReq = (XSelectionRequestEvent*)xev; XSelectionRequestEvent *cbReq = (XSelectionRequestEvent*)xev;
XSelectionEvent cbRes; XSelectionEvent cbRes;


@@ -907,7 +933,7 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
{ {
if(0 == lglw->parent_xwnd) if(0 == lglw->parent_xwnd)
{ {
printf("lglw_linux:loc_eventProc: no parent window to send events to");
Dlog("lglw:loc_eventProc: no parent window to send events to");
XSendEvent(lglw->xdsp, InputFocus, True/*propgate*/, NoEventMask, xev); XSendEvent(lglw->xdsp, InputFocus, True/*propgate*/, NoEventMask, xev);
} }
else else
@@ -924,16 +950,18 @@ static void loc_eventProc(XEvent *xev, lglw_int_t *lglw) {
static void loc_XEventProc(void *_xevent) { static void loc_XEventProc(void *_xevent) {
XEvent *xev = (XEvent*)_xevent; XEvent *xev = (XEvent*)_xevent;


Dlog_verbose("XEventProc\n");
// printf("vstgltest<lglw_linux>: XEventProc, xev=%p\n", xev);
Dlog_vvv("lglw:loc_XEventProc: ENTER\n");
// Dlog_vvv("lglw: XEventProc, xev=%p\n", xev);


if(NULL != xev) if(NULL != xev)
{ {
LGLW(loc_getProperty(xev->xany.display, xev->xany.window, "_lglw")); // get instance pointer LGLW(loc_getProperty(xev->xany.display, xev->xany.window, "_lglw")); // get instance pointer
Dlog_verbose("lglw_linux:loc_XEventProc: xev=%p lglw=%p\n", xev, lglw);
Dlog_vvv("lglw:loc_XEventProc: xev=%p lglw=%p\n", xev, lglw);


loc_eventProc(xev, lglw); loc_eventProc(xev, lglw);
} }

Dlog_vvv("lglw:loc_XEventProc: LEAVE\n");
} }


static void loc_setProperty(Display *_display, Window _window, const char *_name, void *_value) { static void loc_setProperty(Display *_display, Window _window, const char *_name, void *_value) {
@@ -944,7 +972,7 @@ static void loc_setProperty(Display *_display, Window _window, const char *_name
temp[0] = (long)(data & 0xffffffffUL); temp[0] = (long)(data & 0xffffffffUL);
temp[1] = (long)(data >> 32L); temp[1] = (long)(data >> 32L);


printf("xxx lglw_linux:loc_setProperty: name=\"%s\" value=%p temp[0]=%08x temp[1]=%08x\n", _name, _value, (uint32_t)temp[0], (uint32_t)temp[1]);
Dlog_v("lglw:loc_setProperty: name=\"%s\" value=%p temp[0]=%08x temp[1]=%08x\n", _name, _value, (uint32_t)temp[0], (uint32_t)temp[1]);


Atom atom = XInternAtom(_display, _name, False/*only_if_exists*/); Atom atom = XInternAtom(_display, _name, False/*only_if_exists*/);


@@ -988,54 +1016,45 @@ static void *loc_getProperty(Display *_display, Window _window, const char *_nam
} uptr; } uptr;
uptr.any = 0; uptr.any = 0;


// printf("xxx lglw_linux: loc_getProperty: LOWER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);
Dlog_vvv("lglw:loc_getProperty: LOWER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);


if(NULL != data) if(NULL != data)
{ {
if(userCount >= 1) if(userCount >= 1)
{ {
// if(userCount >= 2)
// {
// printf("xxx loc_getProperty: lo=0x%08x hi=0x%08x\n", ((uint32_t*)data)[0], ((uint32_t*)data)[1]);
// }

// lower 32-bit // lower 32-bit
uptr.ui[0] = *(long*)data; uptr.ui[0] = *(long*)data;
uptr.ui[1] = 0; uptr.ui[1] = 0;


// printf("xxx lower=0x%08x\n", uptr.ui[0]);
// // printf("xxx upper=0x%08x\n", uptr.ui[1]);
Dlog_vvv("lglw:loc_getProperty: lower=0x%08x\n", uptr.ui[0]);


XFree(data); XFree(data);


// // if(userCount >= 2)
XGetWindowProperty(_display,
_window,
atom,
1/*offset*/,
1/*length*/,
False/*delete*/,
AnyPropertyType,
&userType/*actual_type_return*/,
&userSize/*actual_format_return*/,
&userCount/*nitems_return*/,
&bytes/*bytes_after_return / partial reads*/,
&data);

Dlog_vvv("lglw:loc_getProperty: UPPER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);
if(NULL != data)
{ {
XGetWindowProperty(_display,
_window,
atom,
1/*offset*/,
1/*length*/,
False/*delete*/,
AnyPropertyType,
&userType/*actual_type_return*/,
&userSize/*actual_format_return*/,
&userCount/*nitems_return*/,
&bytes/*bytes_after_return / partial reads*/,
&data);

// printf("xxx lglw_linux: loc_getProperty: UPPER userSize=%d userCount=%lu bytes=%lu data=%p\n", userSize, userCount, bytes, data);
if(NULL != data)
{
// upper 32-bit
uptr.ui[1] = *(long*)data;
// printf("xxx upper=0x%08x\n", uptr.ui[1]);
XFree(data);
}
// upper 32-bit
uptr.ui[1] = *(long*)data;
Dlog_vvv("lglw:loc_getProperty: upper=0x%08x\n", uptr.ui[1]);
XFree(data);
} }
} }
} }


// printf("xxx lglw_linux: loc_getProperty: return value=%p\n", uptr.any);
Dlog_vvv("lglw:loc_getProperty: return value=%p\n", uptr.any);


return uptr.any; return uptr.any;
} }
@@ -1050,7 +1069,7 @@ static void loc_setEventProc (Display *display, Window window) {
size_t data = (size_t)loc_eventProc; size_t data = (size_t)loc_eventProc;
long temp[2]; long temp[2];


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


// Split the 64 bit pointer into a little-endian unsigned int array // Split the 64 bit pointer into a little-endian unsigned int array
temp[0] = (uint32_t)(data & 0xffffffffUL); temp[0] = (uint32_t)(data & 0xffffffffUL);
@@ -1098,7 +1117,7 @@ static void loc_setEventProc (Display *display, Window window) {
memcpy(ptr, kJumpInstructions, sizeof(kJumpInstructions)); memcpy(ptr, kJumpInstructions, sizeof(kJumpInstructions));
*((uint64_t *)(ptr + kJumpAddress)) = (uint64_t)(&loc_XEventProc); *((uint64_t *)(ptr + kJumpAddress)) = (uint64_t)(&loc_XEventProc);
msync(ptr, sizeof(kJumpInstructions), MS_INVALIDATE); msync(ptr, sizeof(kJumpInstructions), MS_INVALIDATE);
printf("vstgltest<lglw_linux>: 64bit trampoline installed\n");
Dlog("lglw: 64bit trampoline installed\n");
} }
} }


@@ -1140,26 +1159,26 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("lglw:lglw_window_open: 1, %p, %i \n", (Window)_parentHWNDOrNull, (Window)_parentHWNDOrNull);
Dlog_v("lglw:lglw_window_open: 1, %p, %i \n", (Window)_parentHWNDOrNull, (Window)_parentHWNDOrNull);
lglw->parent_xwnd = (0 == _parentHWNDOrNull) ? DefaultRootWindow(lglw->xdsp) : (Window)_parentHWNDOrNull; lglw->parent_xwnd = (0 == _parentHWNDOrNull) ? DefaultRootWindow(lglw->xdsp) : (Window)_parentHWNDOrNull;


lglw_log("lglw:lglw_window_open: 2 lglw=%p\n", lglw);
Dlog_v("lglw:lglw_window_open: 2 lglw=%p\n", lglw);
if(_w <= 16) if(_w <= 16)
_w = lglw->hidden.size.x; _w = lglw->hidden.size.x;


lglw_log("lglw:lglw_window_open: 3\n");
Dlog_v("lglw:lglw_window_open: 3\n");
if(_h <= 16) if(_h <= 16)
_h = lglw->hidden.size.y; _h = lglw->hidden.size.y;


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


lglw_log("lglw:lglw_window_open: 4\n");
Dlog_v("lglw:lglw_window_open: 4\n");
XSetWindowAttributes swa; XSetWindowAttributes swa;
// // XEvent event; // // XEvent event;
XSync(lglw->xdsp, False); XSync(lglw->xdsp, False);


#if 1 #if 1
lglw_log("lglw:lglw_window_open: 5\n");
Dlog_v("lglw:lglw_window_open: 5\n");
swa.border_pixel = 0; swa.border_pixel = 0;
swa.colormap = lglw->cmap; swa.colormap = lglw->cmap;
// (note) [bsp] setting this to NoEventMask causes all events to be propagated to the parent (host) window. // (note) [bsp] setting this to NoEventMask causes all events to be propagated to the parent (host) window.
@@ -1179,7 +1198,7 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,
&swa/*attributes*/ &swa/*attributes*/
); );


lglw_log("lglw:lglw_window_open: 6\n");
Dlog_v("lglw:lglw_window_open: 6\n");
XSetStandardProperties(lglw->xdsp/*display*/, XSetStandardProperties(lglw->xdsp/*display*/,
lglw->win.xwnd/*window*/, lglw->win.xwnd/*window*/,
"LGLW"/*window_name*/, "LGLW"/*window_name*/,
@@ -1192,7 +1211,7 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,


// Setup the event proc now, on the parent window as well just for the debug host // Setup the event proc now, on the parent window as well just for the debug host
// It was simpler to do this than check in the debug host for the reparent event // It was simpler to do this than check in the debug host for the reparent event
lglw_log("lglw:lglw_window_open: 7\n");
Dlog_v("lglw:lglw_window_open: 7\n");
loc_setEventProc(lglw->xdsp, lglw->win.xwnd); loc_setEventProc(lglw->xdsp, lglw->win.xwnd);
loc_setProperty(lglw->xdsp, lglw->win.xwnd, "_lglw", (void*)lglw); // set instance pointer loc_setProperty(lglw->xdsp, lglw->win.xwnd, "_lglw", (void*)lglw); // set instance pointer


@@ -1209,7 +1228,7 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,
// (note) [cameronleger] In Ardour's code-base, the only time it looks for the _XEventProc is during a ReparentNotify event // (note) [cameronleger] In Ardour's code-base, the only time it looks for the _XEventProc is during a ReparentNotify event
if (0 != _parentHWNDOrNull) if (0 != _parentHWNDOrNull)
{ {
lglw_log("lglw:lglw_window_open: 8\n");
Dlog_v("lglw:lglw_window_open: 8\n");
XReparentWindow(lglw->xdsp, lglw->win.xwnd, lglw->parent_xwnd, 0, 0); XReparentWindow(lglw->xdsp, lglw->win.xwnd, lglw->parent_xwnd, 0, 0);
} }
#endif #endif
@@ -1219,7 +1238,7 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,
lglw->win.b_owner = LGLW_FALSE; lglw->win.b_owner = LGLW_FALSE;
#endif #endif


lglw_log("lglw:lglw_window_open: 9\n");
Dlog_v("lglw:lglw_window_open: 9\n");
if(lglw->win.b_owner) if(lglw->win.b_owner)
{ {
// // XMapRaised(lglw->xdsp, lglw->win.xwnd); // // XMapRaised(lglw->xdsp, lglw->win.xwnd);
@@ -1249,14 +1268,14 @@ lglw_bool_t lglw_window_open (lglw_t _lglw, void *_parentHWNDOrNull, int32_t _x,
XSync(lglw->xdsp, False); XSync(lglw->xdsp, False);
lglw->win.mapped = LGLW_TRUE; lglw->win.mapped = LGLW_TRUE;


lglw_log("lglw:lglw_window_open: 10\n");
Dlog_v("lglw:lglw_window_open: 10\n");
lglw->win.size.x = _w; lglw->win.size.x = _w;
lglw->win.size.y = _h; lglw->win.size.y = _h;


lglw_log("lglw:lglw_window_open: 11\n");
Dlog_v("lglw:lglw_window_open: 11\n");
loc_enable_dropfiles(lglw, (NULL != lglw->dropfiles.cbk)); loc_enable_dropfiles(lglw, (NULL != lglw->dropfiles.cbk));


lglw_log("lglw:lglw_window_open: EXIT\n");
Dlog_v("lglw:lglw_window_open: EXIT\n");


r = LGLW_TRUE; r = LGLW_TRUE;
} }
@@ -1273,51 +1292,51 @@ lglw_bool_t lglw_window_resize (lglw_t _lglw, int32_t _w, int32_t _h) {
{ {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
{ {
lglw_log("lglw:lglw_window_resize: 1\n");
Dlog_v("lglw:lglw_window_resize: 1\n");
r = LGLW_TRUE; r = LGLW_TRUE;


lglw_log("lglw:lglw_window_resize: 2\n");
Dlog_v("lglw:lglw_window_resize: 2\n");
XResizeWindow(lglw->xdsp, lglw->win.xwnd, _w, _h); XResizeWindow(lglw->xdsp, lglw->win.xwnd, _w, _h);
XRaiseWindow(lglw->xdsp, lglw->win.xwnd); XRaiseWindow(lglw->xdsp, lglw->win.xwnd);


lglw_log("lglw:lglw_window_resize: 3\n");
Dlog_v("lglw:lglw_window_resize: 3\n");
int deltaW = _w - lglw->win.size.x; int deltaW = _w - lglw->win.size.x;
int deltaH = _h - lglw->win.size.y; int deltaH = _h - lglw->win.size.y;


lglw_log("lglw:lglw_window_resize: 4\n");
Dlog_v("lglw:lglw_window_resize: 4\n");
lglw->win.size.x = _w; lglw->win.size.x = _w;
lglw->win.size.y = _h; lglw->win.size.y = _h;


lglw_log("lglw:lglw_window_resize: 5\n");
Dlog_v("lglw:lglw_window_resize: 5\n");
Window root, parent, *children = NULL; Window root, parent, *children = NULL;
unsigned int num_children; unsigned int num_children;


lglw_log("lglw:lglw_window_resize: 6\n");
Dlog_v("lglw:lglw_window_resize: 6\n");
if(!XQueryTree(lglw->xdsp, lglw->win.xwnd, &root, &parent, &children, &num_children)) if(!XQueryTree(lglw->xdsp, lglw->win.xwnd, &root, &parent, &children, &num_children))
return r; return r;


lglw_log("lglw:lglw_window_resize: 7\n");
Dlog_v("lglw:lglw_window_resize: 7\n");
if(children) if(children)
XFree((char *)children); XFree((char *)children);


lglw_log("lglw:lglw_window_resize: 8\n");
Dlog_v("lglw:lglw_window_resize: 8\n");
// Resize parent window (if any) // Resize parent window (if any)
if(0 != parent) if(0 != parent)
{ {
lglw_log("lglw:lglw_window_resize: 8.1\n");
Dlog_v("lglw:lglw_window_resize: 8.1\n");
int x, y; int x, y;
unsigned int width, height; unsigned int width, height;
unsigned int border_width; unsigned int border_width;
unsigned int depth; unsigned int depth;


lglw_log("lglw:lglw_window_resize: 8.2\n");
Dlog_v("lglw:lglw_window_resize: 8.2\n");
if(!XGetGeometry(lglw->xdsp, lglw->win.xwnd, &root, &x, &y, &width, &height, &border_width, &depth)) if(!XGetGeometry(lglw->xdsp, lglw->win.xwnd, &root, &x, &y, &width, &height, &border_width, &depth))
return r; return r;


lglw_log("lglw:lglw_window_resize: 8.3\n");
Dlog_v("lglw:lglw_window_resize: 8.3\n");
XResizeWindow(lglw->xdsp, parent, width + deltaW, height + deltaH); XResizeWindow(lglw->xdsp, parent, width + deltaW, height + deltaH);
} }
lglw_log("lglw:lglw_window_resize: EXIT\n");
Dlog_v("lglw:lglw_window_resize: EXIT\n");
} }
} }


@@ -1333,13 +1352,13 @@ void lglw_window_close (lglw_t _lglw) {
{ {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
{ {
lglw_log("lglw:lglw_window_close: 1\n");
Dlog_v("lglw:lglw_window_close: 1\n");
lglw_timer_stop(_lglw); lglw_timer_stop(_lglw);


lglw_log("lglw:lglw_window_close: 2\n");
Dlog_v("lglw:lglw_window_close: 2\n");
glXMakeCurrent(lglw->xdsp, None, NULL); glXMakeCurrent(lglw->xdsp, None, NULL);


lglw_log("lglw:lglw_window_close: 3\n");
Dlog_v("lglw:lglw_window_close: 3\n");
if(lglw->win.b_owner) if(lglw->win.b_owner)
{ {
XDestroyWindow(lglw->xdsp, lglw->win.xwnd); XDestroyWindow(lglw->xdsp, lglw->win.xwnd);
@@ -1350,7 +1369,7 @@ void lglw_window_close (lglw_t _lglw) {
lglw->win.mapped = LGLW_FALSE; lglw->win.mapped = LGLW_FALSE;
} }
} }
lglw_log("lglw:lglw_window_close: EXIT\n");
Dlog_v("lglw:lglw_window_close: EXIT\n");
} }




@@ -1360,12 +1379,12 @@ void lglw_window_show(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("lglw:lglw_window_show: 1\n");
Dlog_v("lglw:lglw_window_show: 1\n");
XMapRaised(lglw->xdsp, lglw->win.xwnd); XMapRaised(lglw->xdsp, lglw->win.xwnd);


lglw->win.mapped = LGLW_TRUE; lglw->win.mapped = LGLW_TRUE;
} }
lglw_log("lglw:lglw_window_show: EXIT\n");
Dlog_v("lglw:lglw_window_show: EXIT\n");
} }




@@ -1375,12 +1394,12 @@ void lglw_window_hide(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("lglw:lglw_window_hide: 1\n");
Dlog_v("lglw:lglw_window_hide: 1\n");
XUnmapWindow(lglw->xdsp, lglw->win.xwnd); XUnmapWindow(lglw->xdsp, lglw->win.xwnd);


lglw->win.mapped = LGLW_FALSE; lglw->win.mapped = LGLW_FALSE;
} }
lglw_log("lglw:lglw_window_hide: EXIT\n");
Dlog_v("lglw:lglw_window_hide: EXIT\n");
} }




@@ -1389,14 +1408,14 @@ lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {
lglw_bool_t r = LGLW_FALSE; lglw_bool_t r = LGLW_FALSE;
LGLW(_lglw); LGLW(_lglw);


// lglw_log("lglw:lglw_window_is_visible: 1\n");
Dlog_vvv("lglw:lglw_window_is_visible: 1\n");
if(NULL != lglw && 0 != lglw->win.xwnd) if(NULL != lglw && 0 != lglw->win.xwnd)
{ {
// lglw_log("lglw:lglw_window_is_visible: 2\n");
Dlog_vvv("lglw:lglw_window_is_visible: 2\n");
r = lglw->win.mapped; r = lglw->win.mapped;
} }


// lglw_log("lglw:lglw_window_is_visible: EXIT\n");
Dlog_vvv("lglw:lglw_window_is_visible: EXIT\n");
return r; return r;
} }


@@ -1405,7 +1424,7 @@ lglw_bool_t lglw_window_is_visible(lglw_t _lglw) {
void lglw_window_size_get(lglw_t _lglw, int32_t *_retX, int32_t *_retY) { void lglw_window_size_get(lglw_t _lglw, int32_t *_retX, int32_t *_retY) {
LGLW(_lglw); LGLW(_lglw);


Dlog_verbose("lglw:lglw_window_size_get: 1\n");
Dlog_vvv("lglw:lglw_window_size_get: 1\n");
if(NULL != lglw) if(NULL != lglw)
{ {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
@@ -1417,7 +1436,7 @@ void lglw_window_size_get(lglw_t _lglw, int32_t *_retX, int32_t *_retY) {
*_retY = lglw->win.size.y; *_retY = lglw->win.size.y;
} }
} }
Dlog_verbose("lglw:lglw_window_size_get: EXIT\n");
Dlog_vvv("lglw:lglw_window_size_get: EXIT\n");
} }




@@ -1432,7 +1451,7 @@ void lglw_redraw(lglw_t _lglw) {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
{ {
// TODO Event Loop // TODO Event Loop
Dlog_verbose("lglw:lglw_redraw: 1\n");
Dlog_vvv("lglw:lglw_redraw: 1\n");
XEvent xev; XEvent xev;
xev.xany.type = Expose; xev.xany.type = Expose;
xev.xany.serial = 0; xev.xany.serial = 0;
@@ -1475,11 +1494,11 @@ void lglw_glcontext_push(lglw_t _lglw) {
lglw->prev.drw = glXGetCurrentDrawable(); lglw->prev.drw = glXGetCurrentDrawable();
lglw->prev.ctx = glXGetCurrentContext(); lglw->prev.ctx = glXGetCurrentContext();


// lglw_log("lglw:lglw_glcontext_push: win.xwnd=%p hidden.xwnd=%p ctx=%p\n",
// lglw->win.xwnd, lglw->hidden.xwnd, lglw->ctx);
Dlog_vvv("lglw:lglw_glcontext_push: win.xwnd=%p hidden.xwnd=%p ctx=%p\n",
lglw->win.xwnd, lglw->hidden.xwnd, lglw->ctx);
if(!glXMakeCurrent(lglw->xdsp, (0 == lglw->win.xwnd) ? lglw->hidden.xwnd : lglw->win.xwnd, lglw->ctx)) if(!glXMakeCurrent(lglw->xdsp, (0 == lglw->win.xwnd) ? lglw->hidden.xwnd : lglw->win.xwnd, lglw->ctx))
{ {
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());
Dlog("[---] 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());
} }
} }
} }
@@ -1491,11 +1510,11 @@ void lglw_glcontext_pop(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
// lglw_log("lglw:lglw_glcontext_pop: prev.drw=%p prev.ctx=%p\n",
// lglw->prev.drw, lglw->prev.ctx);
Dlog_vvv("lglw:lglw_glcontext_pop: prev.drw=%p prev.ctx=%p\n",
lglw->prev.drw, lglw->prev.ctx);
if(!glXMakeCurrent(lglw->xdsp, lglw->prev.drw, lglw->prev.ctx)) if(!glXMakeCurrent(lglw->xdsp, lglw->prev.drw, lglw->prev.ctx))
{ {
lglw_log("[---] lglw_glcontext_pop: glXMakeCurrent() failed. prev.drw=%p ctx=%p glGetError()=%d\n", lglw->prev.drw, lglw->prev.ctx, glGetError());
Dlog("[---] lglw_glcontext_pop: glXMakeCurrent() failed. prev.drw=%p ctx=%p glGetError()=%d\n", lglw->prev.drw, lglw->prev.ctx, glGetError());
} }
} }
} }
@@ -1509,7 +1528,7 @@ void lglw_swap_buffers(lglw_t _lglw) {
{ {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
{ {
// lglw_log("lglw:lglw_swap_buffers: 1\n");
Dlog_vv("lglw:lglw_swap_buffers: 1\n");
glXSwapBuffers(lglw->xdsp, lglw->win.xwnd); glXSwapBuffers(lglw->xdsp, lglw->win.xwnd);
} }
} }
@@ -1525,12 +1544,12 @@ void lglw_swap_interval_set(lglw_t _lglw, int32_t _ival) {
{ {
if(0 != lglw->win.xwnd) if(0 != lglw->win.xwnd)
{ {
lglw_log("lglw:lglw_swap_interval_set: 1\n");
Dlog_vv("lglw:lglw_swap_interval_set: 1\n");
PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT; PFNWGLEXTSWAPINTERVALPROC glXSwapIntervalEXT;
glXSwapIntervalEXT = (PFNWGLEXTSWAPINTERVALPROC) glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT"); glXSwapIntervalEXT = (PFNWGLEXTSWAPINTERVALPROC) glXGetProcAddress((const GLubyte*)"glXSwapIntervalEXT");
if(NULL != glXSwapIntervalEXT) if(NULL != glXSwapIntervalEXT)
{ {
lglw_log("lglw:lglw_swap_interval_set: 2\n");
Dlog_vv("lglw:lglw_swap_interval_set: 2\n");
glXSwapIntervalEXT(lglw->xdsp, lglw->win.xwnd, _ival); glXSwapIntervalEXT(lglw->xdsp, lglw->win.xwnd, _ival);
lglw->win.swap_interval = _ival; lglw->win.swap_interval = _ival;
} }
@@ -1562,7 +1581,7 @@ static void loc_handle_mouseleave(lglw_int_t *lglw) {
lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE); lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE);
} }


lglw_log("xxx lglw:loc_handle_mouseleave: LEAVE\n");
Dlog_vv("xxx lglw:loc_handle_mouseleave: LEAVE\n");
} }




@@ -1576,7 +1595,7 @@ static void loc_handle_mouseenter(lglw_int_t *lglw) {
lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE); lglw->focus.cbk(lglw, lglw->focus.state, LGLW_FOCUS_MOUSE);
} }


lglw_log("xxx lglw:loc_handle_mouseenter: LEAVE\n");
Dlog_vv("xxx lglw:loc_handle_mouseenter: LEAVE\n");
} }




@@ -1724,7 +1743,7 @@ void lglw_mouse_grab(lglw_t _lglw, uint32_t _grabMode) {
CurrentTime/*time*/); CurrentTime/*time*/);
if(GrabSuccess != result) if(GrabSuccess != result)
{ {
printf("vstgltest<lglw_linux>: Grab Result: %i\n", result);
Dlog("lglw: Grab Result: %i\n", result);
} }
else else
{ {
@@ -1743,7 +1762,7 @@ void lglw_mouse_grab(lglw_t _lglw, uint32_t _grabMode) {
CurrentTime/*time*/); CurrentTime/*time*/);
if(GrabSuccess != result) if(GrabSuccess != result)
{ {
printf("vstgltest<lglw_linux>: Grab Result: %i\n", result);
Dlog("lglw: Grab Result: %i\n", result);
} }
else else
{ {
@@ -1865,7 +1884,7 @@ void lglw_timer_start(lglw_t _lglw, uint32_t _millisec) {


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("xxx lglw_linux:lglw_timer_start: interval=%u\n", _millisec);
Dlog_v("lglw:lglw_timer_start: interval=%u\n", _millisec);
lglw->timer.interval_ms = _millisec; lglw->timer.interval_ms = _millisec;
lglw->timer.b_running = LGLW_TRUE; lglw->timer.b_running = LGLW_TRUE;
} }
@@ -1878,7 +1897,7 @@ void lglw_timer_stop(lglw_t _lglw) {


if(NULL != lglw) if(NULL != lglw)
{ {
lglw_log("xxx lglw_linux:lglw_timer_stop\n");
Dlog_v("lglw:lglw_timer_stop\n");
lglw->timer.b_running = LGLW_FALSE; lglw->timer.b_running = LGLW_FALSE;
} }
} }
@@ -1907,6 +1926,7 @@ static void loc_process_timer(lglw_int_t *lglw) {


if(NULL != lglw->timer.cbk) if(NULL != lglw->timer.cbk)
{ {
Dlog_vvv("lglw: invoke timer callback\n");
lglw->timer.cbk(lglw); lglw->timer.cbk(lglw);
} }
} }
@@ -1985,7 +2005,7 @@ void lglw_clipboard_text_set(lglw_t _lglw, const uint32_t _numChars, const char
} }
lglw->clipboard.data[numChars - 1] = 0; lglw->clipboard.data[numChars - 1] = 0;


printf("xxx lglw_clipboard_text_set(%i): %s\n", lglw->clipboard.numChars, lglw->clipboard.data);
Dlog("xxx lglw_clipboard_text_set(%i): %s\n", lglw->clipboard.numChars, lglw->clipboard.data);


Atom clipboard = XInternAtom(lglw->xdsp, "CLIPBOARD", False); Atom clipboard = XInternAtom(lglw->xdsp, "CLIPBOARD", False);
XSetSelectionOwner(lglw->xdsp, clipboard, lglw->win.xwnd, CurrentTime); XSetSelectionOwner(lglw->xdsp, clipboard, lglw->win.xwnd, CurrentTime);
@@ -2029,13 +2049,13 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum
owner = XGetSelectionOwner(lglw->xdsp, clipboard); owner = XGetSelectionOwner(lglw->xdsp, clipboard);
if(owner == None) if(owner == None)
{ {
printf("xxx lglw_clipboard_text_get: No Window can provide a clipboard result\n");
Dlog("xxx lglw_clipboard_text_get: No Window can provide a clipboard result\n");
return; return;
} }


if(owner == lglw->win.xwnd) if(owner == lglw->win.xwnd)
{ {
printf("xxx lglw_clipboard_text_get: We are the owner of the clipboard, skip X interactions\n");
Dlog("xxx lglw_clipboard_text_get: We are the owner of the clipboard, skip X interactions\n");


uint32_t i = 0u; uint32_t i = 0u;
for(; i < _maxChars; i++) for(; i < _maxChars; i++)
@@ -2049,7 +2069,7 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum
if(NULL != _retNumChars) if(NULL != _retNumChars)
*_retNumChars = i; *_retNumChars = i;


printf("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);
Dlog("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);
return; return;
} }


@@ -2059,7 +2079,7 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum
cbReq = (XSelectionEvent*)&xev; cbReq = (XSelectionEvent*)&xev;
if(None == cbReq->property) if(None == cbReq->property)
{ {
printf("xxx lglw_clipboard_text_get: Clipboard was not converted to UTF-8 string\n");
Dlog("xxx lglw_clipboard_text_get: Clipboard was not converted to UTF-8 string\n");
return; return;
} }


@@ -2082,13 +2102,13 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum


if(utf8 != returnType) if(utf8 != returnType)
{ {
printf("xxx lglw_clipboard_text_get: Clipboard result is not a UTF-8 string\n");
Dlog("xxx lglw_clipboard_text_get: Clipboard result is not a UTF-8 string\n");
return; return;
} }


if(8u != returnFormat) if(8u != returnFormat)
{ {
printf("xxx lglw_clipboard_text_get: Clipboard format is not a char array\n");
Dlog("xxx lglw_clipboard_text_get: Clipboard format is not a char array\n");
return; return;
} }


@@ -2110,7 +2130,7 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum


if(returnSize == 0) if(returnSize == 0)
{ {
printf("xxx lglw_clipboard_text_get: No Clipboard result after final request\n");
Dlog("xxx lglw_clipboard_text_get: No Clipboard result after final request\n");
return; return;
} }


@@ -2126,7 +2146,7 @@ void lglw_clipboard_text_get(lglw_t _lglw, uint32_t _maxChars, uint32_t *_retNum
if(NULL != _retNumChars) if(NULL != _retNumChars)
*_retNumChars = i; *_retNumChars = i;


printf("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);
Dlog("xxx lglw_clipboard_text_get: (result on next line)\n%s\n", _retText);
XFree(propertyValue); XFree(propertyValue);
} }
} }
@@ -2146,14 +2166,14 @@ void lglw_events(lglw_t _lglw) {
int numEv = XEventsQueued(lglw->xdsp, QueuedAfterReading); int numEv = XEventsQueued(lglw->xdsp, QueuedAfterReading);
// => numEv is always 0 // => numEv is always 0
int evIdx = 0; int evIdx = 0;
printf("xxx lglw_events: numEv=%d\n", numEv);
Dlog_v("xxx lglw_events: numEv=%d\n", numEv);


//for(; evIdx < numEv; evIdx++) //for(; evIdx < numEv; evIdx++)
for(;;) for(;;)
{ {
XEvent xev; XEvent xev;
XNextEvent(lglw->xdsp, &xev); XNextEvent(lglw->xdsp, &xev);
printf("xxx lglw_events: XNextEvent[%d]\n", evIdx++);
Dlog_v("xxx lglw_events: XNextEvent[%d]\n", evIdx++);
loc_eventProc(&xev, lglw); loc_eventProc(&xev, lglw);
} }
#else #else
@@ -2163,7 +2183,7 @@ void lglw_events(lglw_t _lglw) {
// // XEvent xev; // // XEvent xev;
// // // => blocks forever // // // => blocks forever
// // XNextEvent(lglw->xdsp, &xev); // // XNextEvent(lglw->xdsp, &xev);
// // printf("xxx XNextEvent[%d]\n", evIdx++);
// // Dlog_v("xxx XNextEvent[%d]\n", evIdx++);
// // } // // }


loc_process_timer(lglw); loc_process_timer(lglw);


Write Preview
Loading…
Cancel
Save