diff options
Diffstat (limited to 'x11vnc/userinput.c')
| -rw-r--r-- | x11vnc/userinput.c | 802 |
1 files changed, 799 insertions, 3 deletions
diff --git a/x11vnc/userinput.c b/x11vnc/userinput.c index 3c02fb0..60fa75d 100644 --- a/x11vnc/userinput.c +++ b/x11vnc/userinput.c @@ -53,10 +53,9 @@ int check_xrecord(void); int check_wireframe(void); int fb_update_sent(int *count); int check_user_input(double dt, double dtr, int tile_diffs, int *cnt); - +void do_copyregion(sraRegionPtr region, int dx, int dy); static void get_client_regions(int *req, int *mod, int *cpy, int *num) ; -static void do_copyregion(sraRegionPtr region, int dx, int dy) ; static void parse_scroll_copyrect_str(char *scr); static void parse_wireframe_str(char *wf); static void destroy_str_list(char **list); @@ -81,6 +80,8 @@ static void check_user_input2(double dt); static void check_user_input3(double dt, double dtr, int tile_diffs); static void check_user_input4(double dt, double dtr, int tile_diffs); +winattr_t *cache_list; +int lookup_win_index(Window); /* * For -wireframe: find the direct child of rootwin that has the @@ -1757,7 +1758,7 @@ static void get_client_regions(int *req, int *mod, int *cpy, int *num) { * is being done. Note that copyrect under the scaling case is often * only approximate. */ -static void do_copyregion(sraRegionPtr region, int dx, int dy) { +void do_copyregion(sraRegionPtr region, int dx, int dy) { sraRectangleIterator *iter; sraRect rect; int Bpp0 = bpp/8, Bpp; @@ -3364,6 +3365,7 @@ int check_wireframe(void) { double max_spin = wireframe_t3; double min_draw = wireframe_t4; int try_it = 0; + Window desc[6]; DB_SET if (unixpw_in_progress) return 0; @@ -3837,6 +3839,43 @@ if (db) fprintf(stderr, "sent_copyrect: %d - obs: %d frame: 0x%lx\n", sent_copy /* no diff for now... */ fb_push_wait(0.1, FB_COPY); } +#ifndef NO_NCACHE + if (ncache > 0) { + int idx = lookup_win_index(frame); +fprintf(stderr, "sent_copyrect: idx=%d 0x%x\n", idx, frame); + if (idx < 0) { + idx = lookup_win_index(orig_frame); +fprintf(stderr, "sent_copyrect: idx=%d 0x%x\n", idx, orig_frame); + } + if (idx >= 0 && cache_list[idx].su_time > 0.0) { + sraRegionPtr r0, r1, r2; + sraRectangleIterator *iter; + sraRect rt; + int su_x = cache_list[idx].su_x; + int su_y = cache_list[idx].su_y; + int dx, dy; + + r0 = sraRgnCreateRect(0, 0, dpy_x, dpy_y); + r1 = sraRgnCreateRect(orig_x, orig_y, orig_x + orig_w, orig_y + orig_h); + sraRgnAnd(r1, r0); + r2 = sraRgnCreateRect(x, y, x + w, y + h); + sraRgnAnd(r2, r0); + sraRgnSubtract(r1, r2); + + dx = orig_x - su_x; + dy = orig_y - su_y; +fprintf(stderr, "sent_copyrect: su_restore: %d %d\n", dx, dy); + do_copyregion(r1, dx, dy); + fb_push_wait(0.1, FB_COPY); +fprintf(stderr, "sent_copyrect: su_restore: done.\n"); + sraRgnDestroy(r0); + sraRgnDestroy(r1); + sraRgnDestroy(r2); + + cache_list[idx].su_time = 0.0; + } + } +#endif if (scaling) { static double last_time = 0.0; double now = dnow(), delay = 0.35; @@ -4504,4 +4543,761 @@ if (debug_scroll && rc > 1) fprintf(stderr, " CXR: check_user_input ret %d\n", return 0; } +#if defined(NO_NCACHE) || NO_X11 +void check_ncache(void) { + return; +} +int lookup_win_index(Window win) { + return -1; +} +#else +/* maybe ncache.c it if works */ + +winattr_t* cache_list = NULL; +int cache_list_num = 0; +int cache_list_len = 0; + +void snapshot_cache_list(int free_only, double allowed_age) { + static double last_snap = 0.0, last_free = 0.0; + double now; + int num, rc, i, j; + unsigned int ui; + Window r, w; + Window *list; + int start = 2048; + + if (! cache_list) { + cache_list = (winattr_t *) malloc(start*sizeof(winattr_t)); + cache_list_num = 0; + cache_list_len = start; + } + + dtime0(&now); + if (free_only) { + /* we really don't free it, just reset to zero windows */ + cache_list_num = 0; + last_free = now; + return; + } + + if (cache_list_num && now < last_snap + allowed_age) { + return; + } + + cache_list_num = 0; + last_free = now; + +#ifdef MACOSX + if (! macosx_console) { + RAWFB_RET_VOID + } +#else + RAWFB_RET_VOID +#endif + +#if NO_X11 && !defined(MACOSX) + return; +#else + + X_LOCK; + /* no need to trap error since rootwin */ + rc = XQueryTree_wr(dpy, rootwin, &r, &w, &list, &ui); + num = (int) ui; + + if (! rc) { + cache_list_num = 0; + last_free = now; + last_snap = 0.0; + X_UNLOCK; + return; + } + + last_snap = now; + if (num > cache_list_len) { + int n = 2*num; + free(cache_list); + cache_list = (winattr_t *) malloc(n*sizeof(winattr_t)); + cache_list_len = n; + } + j = 0; + for (i=0; i<num; i++) { + cache_list[j].win = list[i]; + cache_list[j].fetched = 0; + cache_list[j].valid = 0; + cache_list[j].time = now; + cache_list[j].selectinput = 0; + j++; + } + cache_list_num = num; + XFree_wr(list); + X_UNLOCK; +#endif /* NO_X11 */ +} + +#define NRECENT 32 +Window recent[NRECENT]; +int recidx[NRECENT]; +int rlast, rfree; + +int lookup_win_index(Window win) { + int k, idx = -1; + int foundfree = 0; + + if (win == rootwin || win == None) { + return idx; + } + for (k = 0; k < NRECENT; k++) { + if (recent[k] == win) { + int k2 = recidx[k]; + if (cache_list[k2].win == win) { + idx = k2; +fprintf(stderr, "recentA: %d 0x%x\n", idx, win); + break; + } + } + } + if (idx < 0) { + for(k=0; k<cache_list_num; k++) { + if (!foundfree && cache_list[k].win == None) { + rfree = k; + foundfree = 1; + } + if (cache_list[k].win == win) { + idx = k; +fprintf(stderr, "recentB: %d 0x%x\n", idx, win); + break; + } + } + if (idx >= 0) { + recent[rlast] = win; + recidx[rlast++] = idx; + rlast = rlast % NRECENT; + } + } +if (idx < 0) { +fprintf(stderr, "recentC: %d 0x%x\n", idx, win); +} + return idx; +} + +int lookup_free_index(void) { + int k; + + if (rfree >= 0) { + if (cache_list[rfree].win == None) { +fprintf(stderr, "lookup_freeA: %d\n", rfree); + return rfree; + } + } + rfree = -1; + for(k=0; k<cache_list_num; k++) { + if (cache_list[k].win == None) { + rfree = k; + break; + } + } + if (rfree < 0) { + rfree = cache_list_num++; + if (rfree >= cache_list_len) { + /* bad news... */ + fprintf(stderr, "Whoops: %d %d\n", rfree, cache_list_len); + } + } +fprintf(stderr, "lookup_freeB: %d\n", rfree); + return rfree; +} + +#define STORE(k, w, attr) \ + cache_list[k].win = w; \ + cache_list[k].fetched = 1; \ + cache_list[k].valid = 1; \ + cache_list[k].x = attr.x; \ + cache_list[k].y = attr.y; \ + cache_list[k].width = attr.width; \ + cache_list[k].height = attr.height; \ + cache_list[k].map_state = attr.map_state; \ + cache_list[k].time = dnow(); + +#define CLEAR(k) \ + cache_list[k].bs_x = -1; \ + cache_list[k].bs_y = -1; \ + cache_list[k].bs_w = -1; \ + cache_list[k].bs_h = -1; \ + cache_list[k].su_x = -1; \ + cache_list[k].su_y = -1; \ + cache_list[k].su_w = -1; \ + cache_list[k].su_h = -1; \ + cache_list[k].bs_time = 0.0; \ + cache_list[k].su_time = 0.0; \ + cache_list[k].selectinput = 0; + +#define DELETE(k) \ + cache_list[k].win = None; \ + cache_list[k].fetched = 0; \ + cache_list[k].valid = 0; \ + free_rect(k); + +char *Etype(int type) { + if (type == KeyPress) return "KeyPress"; + if (type == KeyRelease) return "KeyRelease"; + if (type == ButtonPress) return "ButtonPress"; + if (type == ButtonRelease) return "ButtonRelease"; + if (type == MotionNotify) return "MotionNotify"; + if (type == EnterNotify) return "EnterNotify"; + if (type == LeaveNotify) return "LeaveNotify"; + if (type == FocusIn) return "FocusIn"; + if (type == FocusOut) return "FocusOut"; + if (type == KeymapNotify) return "KeymapNotify"; + if (type == Expose) return "Expose"; + if (type == GraphicsExpose) return "GraphicsExpose"; + if (type == NoExpose) return "NoExpose"; + if (type == VisibilityNotify) return "VisibilityNotify"; + if (type == CreateNotify) return "CreateNotify"; + if (type == DestroyNotify) return "DestroyNotify"; + if (type == UnmapNotify) return "UnmapNotify"; + if (type == MapNotify) return "MapNotify"; + if (type == MapRequest) return "MapRequest"; + if (type == ReparentNotify) return "ReparentNotify"; + if (type == ConfigureNotify) return "ConfigureNotify"; + if (type == ConfigureRequest) return "ConfigureRequest"; + if (type == GravityNotify) return "GravityNotify"; + if (type == ResizeRequest) return "ResizeRequest"; + if (type == CirculateNotify) return "CirculateNotify"; + if (type == CirculateRequest) return "CirculateRequest"; + if (type == PropertyNotify) return "PropertyNotify"; + if (type == SelectionClear) return "SelectionClear"; + if (type == SelectionRequest) return "SelectionRequest"; + if (type == SelectionNotify) return "SelectionNotify"; + if (type == ColormapNotify) return "ColormapNotify"; + if (type == ClientMessage) return "ClientMessage"; + if (type == MappingNotify) return "MappingNotify"; + if (type == LASTEvent) return "LASTEvent"; + return "Unknown"; +} +sraRegionPtr rect_reg[32]; + +int find_rect(int idx, int x, int y, int w, int h) { + static int first = 1; + sraRegionPtr r1, r2; + sraRectangleIterator *iter; + sraRect rt; + int n, x_hit = -1, y_hit = -1; + + if (first) { + first = 0; + for (n = 1; n <= ncache; n++) { + rect_reg[n] = sraRgnCreateRect(0, n * dpy_y, dpy_x, (n+1) * dpy_y); + } + } + + for (n = 1; n < ncache; n += 2) { + r1 = rect_reg[n]; + r2 = NULL; + iter = sraRgnGetIterator(r1); + while (sraRgnIteratorNext(iter, &rt)) { + int rw = nabs(rt.x2 - rt.x1); + int rh = nabs(rt.y2 - rt.y1); + if (rw >= w && rh >= h) { + if (rt.x1 < rt.x2) { + x_hit = rt.x1; + } else { + x_hit = rt.x2; + } + if (rt.y1 < rt.y2) { + y_hit = rt.y1; + } else { + y_hit = rt.y2; + } + r2 = sraRgnCreateRect(x_hit, y_hit, x_hit + w, y_hit + h); + break; + } + } + sraRgnReleaseIterator(iter); + if (r2 != NULL) { + sraRgnSubtract(r1, r2); + sraRgnDestroy(r2); + break; + } + } + if (x_hit < 0) { + /* bad news */ + fprintf(stderr, "*FAIL rect: %d %d %d %d -- %d %d\n", x, y, w, h, x_hit, y_hit); + } else { + fprintf(stderr, "found rect: %d %d %d %d -- %d %d\n", x, y, w, h, x_hit, y_hit); + } + + cache_list[idx].bs_x = x_hit; + cache_list[idx].bs_y = y_hit; + cache_list[idx].bs_w = w; + cache_list[idx].bs_h = h; + + cache_list[idx].su_x = x_hit; + cache_list[idx].su_y = y_hit + dpy_y; + cache_list[idx].su_w = w; + cache_list[idx].su_h = h; +} + +int free_rect(int idx) { + int n, ok = 0; + sraRegionPtr r1, r2; + int x, y, w, h; + + x = cache_list[idx].bs_x; + y = cache_list[idx].bs_y; + w = cache_list[idx].bs_w; + h = cache_list[idx].bs_h; + + if (x < 0) { + CLEAR(idx); +fprintf(stderr, "free_rect: invalid: %d\n", idx); + return 0; + } + + r2 = sraRgnCreateRect(x, y, x+w, y+h); + + for (n = 1; n < ncache; n += 2) { + if (y >= n*dpy_y && y < (n+1)*dpy_y) { + r1 = rect_reg[n]; + sraRgnOr(r1, r2); + ok = 1; +fprintf(stderr, "free_rect: found %d region: %d\n", idx, n); + break; + } + } + sraRgnDestroy(r2); + + CLEAR(idx); +if (! ok) fprintf(stderr, "free_rect: not-found %d\n", idx); + return ok; +} + +int bs_save(int idx) { + Window win = cache_list[idx].win; + XWindowAttributes attr; + int x1, y1, w1, h1; + int x2, y2, w2, h2; + int x, y, w, h; + int dx, dy; + sraRegionPtr r; + + + x1 = cache_list[idx].x; + y1 = cache_list[idx].y; + w1 = cache_list[idx].width; + h1 = cache_list[idx].height; + + if (! valid_window(win, &attr, 1)) { +fprintf(stderr, "bs_save: not valid\n"); +// DELETE(idx); + return 0; + } + + x2 = attr.x; + y2 = attr.y; + w2 = attr.width; + h2 = attr.height; + + if (cache_list[idx].bs_x < 0 || w2 > cache_list[idx].bs_w || h2 > cache_list[idx].bs_h) { + find_rect(idx, x2, y2, w2, h2); + } + x = cache_list[idx].bs_x; + y = cache_list[idx].bs_y; + w = cache_list[idx].bs_w; + h = cache_list[idx].bs_h; + + if (x < 0) { + STORE(idx, win, attr); + return 0; + } + + dx = x - x2; + dy = y - y2; + + r = sraRgnCreateRect(x2+dx, y2+dy, x2+w2+dx, y2+h2+dy); +fprintf(stderr, "bs_save: dx=%d dy=%d\n", dx, dy); + do_copyregion(r, dx, dy); + fb_push_wait(0.01, FB_COPY); +fprintf(stderr, "bs_save: done. %dx%d+%d+%d %dx%d+%d+%d %.2f %.2f\n", w1, h1, x1, y1, w2, h2, x2, y2, cache_list[idx].bs_time, dnow()); + sraRgnDestroy(r); + + STORE(idx, win, attr); + cache_list[idx].bs_time = dnow(); + + return 1; +} + +int su_save(int idx) { + Window win = cache_list[idx].win; + XWindowAttributes attr; + int x1, y1, w1, h1; + int x2, y2, w2, h2; + int x, y, w, h; + int dx, dy; + sraRegionPtr r; + + + x1 = cache_list[idx].x; + y1 = cache_list[idx].y; + w1 = cache_list[idx].width; + h1 = cache_list[idx].height; + + if (! valid_window(win, &attr, 1)) { +fprintf(stderr, "su_save: not valid\n"); +// DELETE(idx); + return 0; + } + + x2 = attr.x; + y2 = attr.y; + w2 = attr.width; + h2 = attr.height; + + if (cache_list[idx].su_x < 0 || w2 > cache_list[idx].su_w || h2 > cache_list[idx].su_h) { + find_rect(idx, x2, y2, w2, h2); + } + x = cache_list[idx].su_x; + y = cache_list[idx].su_y; + w = cache_list[idx].su_w; + h = cache_list[idx].su_h; + + if (x < 0) { + STORE(idx, win, attr); + return 0; + } + + dx = x - x2; + dy = y - y2; + + r = sraRgnCreateRect(x2+dx, y2+dy, x2+w2+dx, y2+h2+dy); +fprintf(stderr, "su_save: dx=%d dy=%d\n", dx, dy); + do_copyregion(r, dx, dy); + fb_push_wait(0.01, FB_COPY); +fprintf(stderr, "su_save: done. %dx%d+%d+%d %dx%d+%d+%d %.2f %.2f\n", w1, h1, x1, y1, w2, h2, x2, y2, cache_list[idx].su_time, dnow()); + sraRgnDestroy(r); + + STORE(idx, win, attr); + cache_list[idx].su_time = dnow(); + + return 1; +} + +int bs_restore(int idx) { + Window win = cache_list[idx].win; + XWindowAttributes attr; + int x1, y1, w1, h1; + int x2, y2, w2, h2; + int x, y, w, h; + int dx, dy; + sraRegionPtr r; + + if (cache_list[idx].bs_x < 0 || cache_list[idx].bs_time == 0.0) { + return 0; + } + + x1 = cache_list[idx].x; + y1 = cache_list[idx].y; + w1 = cache_list[idx].width; + h1 = cache_list[idx].height; + + if (! valid_window(win, &attr, 1)) { +fprintf(stderr, "bs_restore: not valid\n"); + DELETE(idx); + return 0; + } + + x2 = attr.x; + y2 = attr.y; + w2 = attr.width; + h2 = attr.height; + + x = cache_list[idx].bs_x; + y = cache_list[idx].bs_y; + w = cache_list[idx].bs_w; + h = cache_list[idx].bs_h; + + if (x < 0) { + STORE(idx, win, attr); + return 0; + } + + dx = x2 - x; + dy = y2 - y; + + r = sraRgnCreateRect(x+dx, y+dy, x+w2+dx, y+h2+dy); +fprintf(stderr, "bs_restore: dx=%d dy=%d\n", dx, dy); + do_copyregion(r, dx, dy); + fb_push_wait(0.01, FB_COPY); +fprintf(stderr, "bs_rest: done. %dx%d+%d+%d %dx%d+%d+%d %.2f %.2f\n", w1, h1, x1, y1, w2, h2, x2, y2, cache_list[idx].bs_time, dnow()); + sraRgnDestroy(r); + + STORE(idx, win, attr); + + return 1; +} + +int su_restore(int idx) { + Window win = cache_list[idx].win; + XWindowAttributes attr; + int x1, y1, w1, h1; + int x2, y2, w2, h2; + int x, y, w, h; + int dx, dy; + sraRegionPtr r; + int invalid = 0; + + if (cache_list[idx].su_x < 0 || cache_list[idx].su_time == 0.0) { + return 0; + } + + x1 = cache_list[idx].x; + y1 = cache_list[idx].y; + w1 = cache_list[idx].width; + h1 = cache_list[idx].height; + + if (! valid_window(win, &attr, 1)) { +fprintf(stderr, "su_restore: not valid\n"); + invalid = 1; + x2 = x1; + y2 = y1; + w2 = w1; + h2 = h1; + } else { + x2 = attr.x; + y2 = attr.y; + w2 = attr.width; + h2 = attr.height; + } + + x = cache_list[idx].su_x; + y = cache_list[idx].su_y; + w = cache_list[idx].su_w; + h = cache_list[idx].su_h; + + if (x < 0) { + if (invalid) { + DELETE(idx); + } + return 0; + } + + dx = x2 - x; + dy = y2 - y; + + r = sraRgnCreateRect(x+dx, y+dy, x+w2+dx, y+h2+dy); +fprintf(stderr, "su_restore: dx=%d dy=%d\n", dx, dy); + do_copyregion(r, dx, dy); + fb_push_wait(0.01, FB_COPY); +fprintf(stderr, "su_rest: done. %dx%d+%d+%d %dx%d+%d+%d %.2f %.2f\n", w1, h1, x1, y1, w2, h2, x2, y2, cache_list[idx].su_time, dnow()); + sraRgnDestroy(r); + + if (invalid) { + DELETE(idx); + return 0; + } else { + STORE(idx, win, attr); + return 1; + } +} + +#include <rfb/default8x16.h> + +void check_ncache(void) { + static int last_map = -1; + static double last_root = 0.0; + static int first = 1; + int i, j, k; + double now, refresh = 60.0; + Window win, win2; + XWindowAttributes attr; + XEvent ev; + + if (! ncache || ! ncache0) { + return; + } + if (! screen) { + return; + } + if (! dpy) { + return; + } + + if (first) { + int dx = 10, dy = 24; + for (i=0; i < NRECENT; i++) { + recent[i] = None; + } + rlast = 0; + X_LOCK; + /* event leak with client_count == 0 */ + xselectinput_rootwin |= SubstructureNotifyMask; + XSelectInput(dpy, rootwin, xselectinput_rootwin); + X_UNLOCK; + first = 0; + rfbDrawString(screen, &default8x16Font, dx, dpy_y+1*dy, + "This is the Pixel buffer cache region. Your VNC Viewer is not hiding it from you.", + white_pixel()); + rfbDrawString(screen, &default8x16Font, dx, dpy_y+2*dy, + "Try resizing your VNC Viewer so you don't see it !!", + white_pixel()); + rfbDrawString(screen, &default8x16Font, dx, dpy_y+3*dy, + "To disable run the server with: x11vnc -ncache 0 ...", + white_pixel()); + rfbDrawString(screen, &default8x16Font, dx, dpy_y+4*dy, + "More info: http://www.karlrunge.com/x11vnc/#faq-client-caching", + white_pixel()); + snapshot_cache_list(0, 100.0); + } + + if (! client_count) { + return; + } + now = dnow(); + + if (now > last_root + refresh) { +fprintf(stderr, "\n**** checking cache_list[%d]\n\n", cache_list_num); + for(k=0; k<cache_list_num; k++) { + win = cache_list[k].win; + if (win == None) { +fprintf(stderr, " Empty[%d]: 0x%x\n", k, win); + } else if (cache_list[k].selectinput && cache_list[k].time > now - refresh) { +fprintf(stderr, " Young[%d]: 0x%x\n", k, win); + } else if (valid_window(win, &attr, 1)) { + STORE(k, win, attr); + if (! cache_list[k].selectinput) { + X_LOCK; +fprintf(stderr, " XSelectInput[%d]: 0x%x\n", k, win); + XSelectInput(dpy, win, StructureNotifyMask); + X_UNLOCK; + CLEAR(k); + cache_list[k].selectinput = 1; + } else { +//fprintf(stderr, " SKIP XSelectInput[%d]: 0x%x\n", k, win); + } + } else { +fprintf(stderr, " DELETE(%d) 0x%x\n", k, win); + DELETE(k); + } + } + last_root = dnow(); + } + + X_LOCK; + while (XCheckMaskEvent(dpy, SubstructureNotifyMask|StructureNotifyMask, &ev)) { + int type = ev.type; + int idx; + win = ev.xany.window; + +//fprintf(stderr, "evnt: 0x%x %d pending: %d\n", win, type, XPending(dpy)); + if (win == rootwin) { + if (type == CreateNotify) { + int x=0,y=0,w=0,h=0; + win2 = ev.xcreatewindow.window; + idx = lookup_win_index(win2); + if (idx < 0) { + idx = lookup_free_index(); + } + if (valid_window(win2, &attr, 1)) { + STORE(idx, win2, attr); + CLEAR(idx); +// su_save(idx); // not working + x=attr.x; + y=attr.y; + w=attr.width; + h=attr.height; + XSelectInput(dpy, win2, StructureNotifyMask); + cache_list[idx].selectinput = 1; + } +fprintf(stderr, "root: ** CreateNotify 0x%x %d -- %dx%d+%d+%d\n", win2, idx, w, h, x, y); + } else if (type == ReparentNotify) { + if (ev.xreparent.parent != rootwin) { + win2 = ev.xreparent.window; + if (win2 != rootwin) { + idx = lookup_win_index(win2); +fprintf(stderr, "root: ReparentNotify RM: 0x%x %d\n", win2, idx); + if (idx >= 0) { + DELETE(idx); + } + XSelectInput(dpy, win2, 0); + } + } + } else { + Window ww = None; + /* skip rest */ +if (type == DestroyNotify) ww = ev.xdestroywindow.window; +if (type == UnmapNotify) ww = ev.xunmap.window; +if (type == MapNotify) ww = ev.xmap.window; +if (type == Expose) ww = ev.xexpose.window; +if (type == ConfigureNotify) ww = ev.xconfigure.window; +fprintf(stderr, "root: skip %s for 0x%x\n", Etype(type), ww); + } + } else { + if (type == ReparentNotify) { + if (ev.xreparent.parent != rootwin) { + win2 = ev.xreparent.window; + if (win2 != rootwin) { + idx = lookup_win_index(win2); +fprintf(stderr, "----- ReparentNotify RM: 0x%x %d\n", win2, idx); + if (idx >= 0) { + DELETE(idx); + } + XSelectInput(dpy, win2, 0); + } + } + + } else if (type == DestroyNotify) { + win2 = ev.xdestroywindow.window; + idx = lookup_win_index(win2); +fprintf(stderr, "----- DestroyNotify 0x%x %d\n", win2, idx); + if (idx >= 0) { + DELETE(idx); + } + + } else if (type == ConfigureNotify) { + idx = lookup_win_index(win); +fprintf(stderr, "----- ConfigureNotify 0x%x %d -- %dx%d+%d+%d\n", win, idx, ev.xconfigure.width, ev.xconfigure.height, ev.xconfigure.x, ev.xconfigure.y); + if (idx >= 0) { + /* XXX invalidate su and/or bs */ + cache_list[idx].x = ev.xconfigure.x; + cache_list[idx].y = ev.xconfigure.y; + cache_list[idx].width = ev.xconfigure.width; + cache_list[idx].height = ev.xconfigure.height; + } + + } else if (type == MapNotify) { + idx = lookup_win_index(win); +fprintf(stderr, "----- MapNotify 0x%x %d\n", win, idx); + if (idx < 0) { + continue; + } + if (cache_list[idx].map_state == IsUnmapped) { + X_UNLOCK; + su_save(idx); + bs_restore(idx); + X_LOCK; + } + + } else if (type == UnmapNotify) { + idx = lookup_win_index(win); +fprintf(stderr, "----- UnmapNotify 0x%x %d\n", win, idx); + if (idx < 0) { + continue; + } + if (cache_list[idx].map_state == IsViewable) { + X_UNLOCK; + bs_save(idx); + su_restore(idx); + X_LOCK; + } + } else { + /* skip rest */ +fprintf(stderr, "----- skip %s\n", Etype(type)); + } + } + } +//fprintf(stderr, "pending2: %d\n", XPending(dpy)); + X_UNLOCK; +if (dnow() - now > 0.05) fprintf(stderr, "check_ncache OUT: %f\n", dnow() - now); +} +#endif + |