/*------------------------------------------------ topwindow * * window# true | -- * * make window float above other iff true */ P op_makewindowtop(void) { #if X_DISPLAY_MISSING return NO_XWINDOWS; #else P k; XEvent event; if (dvtdisplay == NULL) return NO_XWINDOWS; if (o_2 < FLOORopds) return OPDS_UNF; if (CLASS(o_1) != BOOL || CLASS(o_2) != NUM) return OPD_CLA; if (!PVALUE(o_2, &wid)) return UNDF_VAL; FREEopds = o_2; for (k = 0; k < ndvtwindows && dvtwindows[k] != wid; k++); if (k == ndvtwindows) return OK; event.xclient.type = ClientMessage; event.xclient.display = dvtdisplay; event.xclient.window = wid; event.xclient.message_type = HXInternAtom(dvtdisplay, "_NET_WM_STATE", False); event.xclient.format = 32; event.xclient.data.l[0] = (BOOL_VAL(o2) ? 1 : 0); event.xclient.data.l[1] = HXInternAtom(dvtdisplay, "_NET_WM_STATE_ABOVE", False); event.xclient.data.l[2] = 0; event.xclient.data.l[3] = 2; event.xclient.data.l[4] = 0; HXSendEvent(dvtdisplay, XRootWindowOfScreen(dvtscreen), False, (SubstructureNotifyMask|SubstructureRedirectMask), &event); return OK; #endif }
void SplashCreateWindow(Splash * splash) { XSizeHints sizeHints; XSetWindowAttributes attr; attr.backing_store = NotUseful; attr.colormap = XDefaultColormapOfScreen(splash->screen); attr.save_under = True; attr.cursor = splash->cursor = XCreateFontCursor(splash->display, XC_watch); attr.event_mask = ExposureMask; SplashCenter(splash); splash->window = XCreateWindow(splash->display, XRootWindowOfScreen(splash->screen), splash->x, splash->y, splash->width, splash->height, 0, CopyFromParent, InputOutput, CopyFromParent, CWColormap | CWBackingStore | CWSaveUnder | CWCursor | CWEventMask, &attr); SplashUpdateSizeHints(splash); splash->wmHints = XAllocWMHints(); if (splash->wmHints) { splash->wmHints->flags = InputHint | StateHint; splash->wmHints->input = False; splash->wmHints->initial_state = NormalState; XSetWMHints(splash->display, splash->window, splash->wmHints); } }
static pBitmapDirectory AddFile( Widget w, String file, String name, pBitmapDirectory bd) { int dummy; tBitmapEntry bitmap_entry; pBitmapDirectory entry; Window win = XRootWindowOfScreen(XtScreen(w)); if(XReadBitmapFile(XtDisplay(w), win, file, &bitmap_entry.width, &bitmap_entry.height, &bitmap_entry.bitmap, &dummy, &dummy) !=BitmapSuccess) return bd; /* Ignore invalid bitmap files */ if(!(entry = FindBitmap(name, bd))) { /* create new entry */ entry = NEW(tBitmapDirectory); entry->next = bd; bd = entry; } /* else replace existent entry! */ entry->bitmap_entry = bitmap_entry; entry->bitmap_entry.name = strdup(name); return bd; }
static void SplashCenter(Splash * splash) { Atom type, atom, actual_type; int status, actual_format; unsigned long nitems, bytes_after; CARD16 *prop = NULL; /* try centering using Xinerama hint if there's no hint, use the center of the screen */ atom = XInternAtom(splash->display, "XINERAMA_CENTER_HINT", True); if (atom != None) { status = XGetWindowProperty(splash->display, XRootWindowOfScreen(splash->screen), atom, 0, 1, False, XA_INTEGER, &actual_type, &actual_format, &nitems, &bytes_after, (unsigned char**)(&prop)); if (status == Success && actual_type != None && prop != NULL) { splash->x = prop[0] - splash->width/2; splash->y = prop[1] - splash->height/2; XFree(prop); return; } if (prop != NULL) { XFree(prop); } } splash->x = (XWidthOfScreen(splash->screen) - splash->width) / 2; splash->y = (XHeightOfScreen(splash->screen) - splash->height) / 2; }
/* * Class: jogamp_nativewindow_x11_X11Lib * Method: GetRelativeLocation * Signature: (JIJJII)Ljavax/media/nativewindow/util/Point; */ JNIEXPORT jobject JNICALL Java_jogamp_nativewindow_x11_X11Lib_GetRelativeLocation0 (JNIEnv *env, jclass unused, jlong jdisplay, jint screen_index, jlong jsrc_win, jlong jdest_win, jint src_x, jint src_y) { Display * dpy = (Display *) (intptr_t) jdisplay; Screen * scrn = ScreenOfDisplay(dpy, (int)screen_index); Window root = XRootWindowOfScreen(scrn); Window src_win = (Window)jsrc_win; Window dest_win = (Window)jdest_win; int dest_x=-1; int dest_y=-1; Window child; Bool res; if( 0 == jdest_win ) { dest_win = root; } if( 0 == jsrc_win ) { src_win = root; } NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 1, errorHandlerQuiet, 0); res = XTranslateCoordinates(dpy, src_win, dest_win, src_x, src_y, &dest_x, &dest_y, &child); // NativewindowCommon_x11ErrorHandlerEnable(env, dpy, 0, 0, errorHandlerQuiet, 0); DBG_PRINT( "X11: GetRelativeLocation0: %p %d/%d -> %p %d/%d - ok: %d\n", (void*)src_win, src_x, src_y, (void*)dest_win, dest_x, dest_y, (int)res); return (*env)->NewObject(env, pointClz, pointCstr, (jint)dest_x, (jint)dest_y); }
static inline void _gfx_x11_leave_fullscreen( GFX_X11_Monitor* monitor) { Window root = XRootWindowOfScreen(monitor->screen); XRRScreenResources* res = XRRGetScreenResources(_gfx_x11.display, root); XRRCrtcInfo* crtc = XRRGetCrtcInfo(_gfx_x11.display, res, monitor->crtc); /* Set mode */ XRRSetCrtcConfig( _gfx_x11.display, res, monitor->crtc, crtc->timestamp, crtc->x, crtc->y, monitor->mode, crtc->rotation, crtc->outputs, crtc->noutput ); XRRFreeCrtcInfo(crtc); XRRFreeScreenResources(res); }
unsigned long XtcwpGetLastPixel (Display *dpy) /***************************************************************************** return last pixel in range of contiguous pixels in XA_RGB_DEFAULT_MAP ****************************************************************************** Input: dpy display ****************************************************************************** Notes: If it does not already exist, XA_RGB_DEFAULT_MAP will be created. If XA_RGB_DEFAULT_MAP does not exist and cannot be created, then this function returns 0. ****************************************************************************** Author: Dave Hale, Colorado School of Mines, 09/29/90 *****************************************************************************/ { Screen *scr=XDefaultScreenOfDisplay(dpy); Window root=XRootWindowOfScreen(scr); XStandardColormap scmap; /* if XA_RGB_DEFAULT_MAP does not exist, create it */ if (!XGetStandardColormap(dpy,root,&scmap,XA_RGB_DEFAULT_MAP)) if (!XtcwpCreateRGBDefaultMap(dpy,&scmap)) return 0; /* return last pixel in range of contiguous pixels */ return scmap.base_pixel+ scmap.red_max*scmap.red_mult+ scmap.green_max*scmap.green_mult+ scmap.blue_max*scmap.blue_mult; }
HelloWorld::HelloWorld(Display* display) : _game() { _display = display; _screen = XDefaultScreenOfDisplay(display); _blackColor = BlackPixelOfScreen(_screen); _whiteColor = WhitePixelOfScreen(_screen); _font = XLoadFont(_display, WINDOW_FONT); int screenWidth = XWidthOfScreen(_screen); int screenHeight = XHeightOfScreen(_screen); int windowWidth = MIN_CELL_SIZE * 3; int windowHeight = MIN_CELL_SIZE * 3 + STRING_HEIGHT * 3; int windowX = (screenWidth + windowWidth) / 2; int windowY = (screenHeight + windowHeight) / 2; _window = XCreateSimpleWindow(_display, XRootWindowOfScreen(_screen), windowX, windowY, windowWidth, windowHeight, 1, _blackColor, _whiteColor); long eventMask = ButtonPressMask | ExposureMask | KeyPressMask; XSelectInput(_display, _window, eventMask); draw(); }
Screen * XpGetScreenOfContext ( Display *dpy, XPContext print_context ) { xPrintGetContextScreenReq *req; xPrintGetContextScreenReply rep; XExtensionVersion *ext; XExtDisplayInfo *info = (XExtDisplayInfo *) xp_find_display (dpy); int i; Screen *checkScr; Screen *screen; int ok; if (XpCheckExtInit(dpy, XP_DONT_CHECK) == -1) return ( (Screen *) NULL ); /* No such extension */ LockDisplay (dpy); GetReq(PrintGetContextScreen,req); req->reqType = info->codes->major_opcode; req->printReqType = X_PrintGetContextScreen; req->printContext = print_context; if (! _XReply (dpy, (xReply *) &rep, 0, xTrue)) { UnlockDisplay(dpy); SyncHandle(); return ( (Screen *) NULL ); /* No such extension */ } /* * Pull rootWindow ID and convert to the corresponding * Screen rec. */ ok = False; for ( i = 0; i < XScreenCount(dpy); i++ ) { checkScr = XScreenOfDisplay(dpy, i); if ( XRootWindowOfScreen( checkScr ) == (Window) rep.rootWindow ) { ok = True; break; } } if (!ok) checkScr = (Screen *) NULL; UnlockDisplay(dpy); SyncHandle(); return ( (Screen *) checkScr ); }
/* This was all basically swiped from driver/remote.c and util/vroot.h */ static Window xsublim_Ss_GetWindow(Display* ss_Display) { Screen *s = DefaultScreenOfDisplay (ss_Display); Window root = XRootWindowOfScreen (s); Window vroot = VirtualRootWindowOfScreen (s); if (root == vroot) return 0; else return vroot; }
unsigned long X11Info::appRootWindow(int screen) { #ifdef HAVE_QT5 return screen == -1? XDefaultRootWindow(display()) : XRootWindowOfScreen(XScreenOfDisplay(display(), screen)); #else return QX11Info::appRootWindow(screen); #endif }
window::pointer screen::IMPL::get_root_win( const screen::pointer & s ) const { if ( !_root ) { screen::IMPL * that = const_cast<screen::IMPL*>( this ); that->_root.reset( new window ); that->_root->_p->_screen = s; that->_root->_p->_native_win = XRootWindowOfScreen( _xscrn ); } return _root; }
static void _gfx_x11_enter_fullscreen( GFX_X11_Monitor* monitor, Window handle, RRMode mode) { Window root = XRootWindowOfScreen(monitor->screen); XRRScreenResources* res = XRRGetScreenResources(_gfx_x11.display, root); XRRCrtcInfo* crtc = XRRGetCrtcInfo(_gfx_x11.display, res, monitor->crtc); /* Above state */ XEvent event; memset(&event, 0, sizeof(XEvent)); event.type = ClientMessage; event.xclient.window = handle; event.xclient.message_type = _gfx_x11.NET_WM_STATE; event.xclient.format = 32; event.xclient.data.l[0] = 1; event.xclient.data.l[1] = _gfx_x11.NET_WM_STATE_ABOVE; /* Send event, set mode and move window */ XSendEvent( _gfx_x11.display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &event); XRRSetCrtcConfig( _gfx_x11.display, res, monitor->crtc, crtc->timestamp, crtc->x, crtc->y, mode, crtc->rotation, crtc->outputs, crtc->noutput); XMoveWindow( _gfx_x11.display, handle, crtc->x, crtc->y); XRRFreeCrtcInfo(crtc); XRRFreeScreenResources(res); }
/*----------------------------------------------------------------------* | RemoveAllCommandsAndExit | *----------------------------------------------------------------------*/ void RemoveAllCommandsAndExit() { Window rootWindow = XRootWindowOfScreen(XtScreen(shell)); PRINT("REMOVE ALL COMMANDS\n"); SendRemoveCommand(0x3fffffff,occupy_id); SendRemoveCommand(0x3fffffff,copy_all_id); SendRemoveCommand(0x3fffffff,link_all_id); SendRemoveCommand(0x3fffffff,remove_id); SendRemoveCommand(0x00000000,switch_id); exiting = True; SendRemoveCommand(0x00000000,show_id); }
static ani_image *name2image(Widget w, char *name) { XpmAttributes xa; ani_image *i; int err; char b[1024]; char tmpfile[1024]; Display *display = XtDisplay(w); Window ani_win = XRootWindowOfScreen(XtScreen(w)); static char *mowitz_data; if (!mowitz_data) mowitz_data = getenv("MOWITZ_DATA"); if (!mowitz_data) mowitz_data = MOWITZ_DATA; if (!XtIsRealized(w)) return NULL; #if 0 /* FIXME */ sprintf(tmpfile, "%s/siagimage.xpm", siag_tmpdir); #else sprintf(tmpfile, "%s/siagimage.xpm", "/tmp"); #endif if (!name) return NULL; for (i = i_list; i; i = i->next) { if (!strcmp(name, i->filename)) return i; } /* didn't find it; try loading */ sprintf(b, "%s/any2xpm %s > %s", mowitz_data, name, tmpfile); system(b); i = (ani_image *)MwMalloc(sizeof(ani_image)); xa.closeness = 40000; xa.exactColors = FALSE; xa.valuemask = XpmCloseness | XpmExactColors; err = XpmReadFileToPixmap(display, ani_win, tmpfile, &(i->pixmap), &(i->mask), &xa); if (err != XpmSuccess) { MwFree(i); fprintf(stderr, "XpmReadFileToPixmap returns %s\n", XpmGetErrorString(err)); return NULL; } remove(tmpfile); i->filename = MwStrdup(name); i->next = i_list; i_list = i; return i; }
void mapraisewindow(P win) { XEvent event; HXMapRaised(dvtdisplay, win); event.xclient.type = ClientMessage; event.xclient.display = dvtdisplay; event.xclient.window = win; event.xclient.message_type = HXInternAtom(dvtdisplay, "_NET_ACTIVE_WINDOW", False); event.xclient.format = 32; event.xclient.data.l[0] = 2; event.xclient.data.l[1] = time(NULL); event.xclient.data.l[2] = 0; event.xclient.data.l[3] = 0; event.xclient.data.l[4] = 0; HXSendEvent(dvtdisplay, XRootWindowOfScreen(dvtscreen), False, (SubstructureNotifyMask|SubstructureRedirectMask), &event); }
/** * Prepare the capture data */ static void xshm_video_tick(void *vptr, float seconds) { UNUSED_PARAMETER(seconds); XSHM_DATA(vptr); if (!data->xshm) return; obs_enter_graphics(); XShmGetImage(data->dpy, XRootWindowOfScreen(data->screen), data->xshm->image, data->x_org, data->y_org, AllPlanes); gs_texture_set_image(data->texture, (void *) data->xshm->image->data, data->width * 4, false); xcursor_tick(data->cursor); obs_leave_graphics(); }
bool GLWindow::create() { GLint glxAttrs[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, GLX_TRANSPARENT_TYPE, GLX_NONE, // GLX_X_RENDERABLE, True, GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, GLX_DOUBLEBUFFER, True, GLX_STEREO, False, GLX_BUFFER_SIZE, 32, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_AUX_BUFFERS, 0, GLX_SAMPLE_BUFFERS, 0, GLX_SAMPLES, 0, GLX_ACCUM_RED_SIZE, 0, GLX_ACCUM_GREEN_SIZE, 0, GLX_ACCUM_BLUE_SIZE, 0, GLX_ACCUM_ALPHA_SIZE, 0, None }; int glxConfigCount = 0; // destroy existing window if any this->destroy(); // check opengl support if (!glXQueryExtension(this->display, NULL, NULL)) { fprintf(stderr, "ERROR: OpenGL not supported!\n"); return false; } // find compatible opengl framebuffer configurations this->glxConfigs = glXChooseFBConfig( this->display, XScreenNumberOfScreen(this->screen), glxAttrs, &glxConfigCount ); if (this->glxConfigs == NULL || glxConfigCount == 0) { fprintf(stderr, "ERROR: No OpenGL framebuffer configuration is compatible!\n"); return false; } // create opengl context this->glxContext = glXCreateNewContext( this->display, this->glxConfigs[0], GLX_RGBA_TYPE, NULL, True ); if (this->glxContext == NULL) { fprintf(stderr, "ERROR: Cannot create OpenGL context!\n"); return false; } // select first compatible configuration this->visualinfo = glXGetVisualFromFBConfig(this->display, this->glxConfigs[0]); if (this->visualinfo == NULL) { fprintf(stderr, "ERROR: OpenGL framebuffer configuration failed!\n"); return false; } // create colormap this->colormap = XCreateColormap( this->display, XRootWindowOfScreen(this->screen), this->visualinfo->visual, AllocNone ); if (this->colormap == None) { fprintf(stderr, "ERROR: Cannot create colormap!\n"); return false; } // create window XSetWindowAttributes attrs; attrs.colormap = this->colormap; attrs.event_mask = StructureNotifyMask | ExposureMask | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask; attrs.cursor = None; this->_width = XDisplayWidth(this->display, XScreenNumberOfScreen(this->screen)); this->_height = XDisplayHeight(this->display, XScreenNumberOfScreen(this->screen)); this->window = XCreateWindow( this->display, XRootWindowOfScreen(this->screen), 0, 0, this->_width, this->_height, 0, // border width this->visualinfo->depth, InputOutput, this->visualinfo->visual, CWEventMask | CWColormap, // | CWCursor, &attrs ); if (this->window == None) { fprintf(stderr, "ERROR: Cannot create window!\n"); return false; } // create opengl framebuffer this->glxWindow = glXCreateWindow( this->display, this->glxConfigs[0], this->window, NULL ); if (this->glxWindow == None) { fprintf(stderr, "ERROR: Cannot create OpenGL framebuffer!\n"); return false; } // register window manager close event this->wm_delete_window = XInternAtom(this->display, "WM_DELETE_WINDOW", false); if (this->wm_delete_window == None) { fprintf(stderr, "ERROR: Cannot create WM_DELETE_WINDOW atom!\n"); return false; } XSetWMProtocols(display, window, &this->wm_delete_window, 1); // show window XMapWindow(this->display, this->window); return true; }
Colormap XtcwpCreateRGBColormap (Display *dpy, Window win) /***************************************************************************** create a colormap with an RGB color scale in contiguous cells ****************************************************************************** Input: dpy display win window ****************************************************************************** Notes: The returned colormap is only created; the window's colormap attribute is not changed, and the colormap is not installed by this function. The returned colormap is a copy of the window's current colormap, but with an RGB color scale allocated in the range of contiguous cells determined by XA_RGB_DEFAULT_MAP. If it does not already exist, XA_RGB_DEFAULT_MAP will be created. ****************************************************************************** Author: Dave Hale, Colorado School of Mines, 09/29/90 *****************************************************************************/ { Screen *scr=XDefaultScreenOfDisplay(dpy); Window root=XRootWindowOfScreen(scr); Colormap cmap,wcmap; XStandardColormap scmap; XColor color; XWindowAttributes wa; unsigned long i,ncells,npixels; unsigned long bpixel,epixel,pixel[4096]; /* determine beginning and ending pixels in contiguous range */ bpixel = XtcwpGetFirstPixel(dpy); epixel = XtcwpGetLastPixel(dpy); if (epixel<=bpixel) return None; /* get standard colormap XA_RGB_DEFAULT_MAP */ if (!XGetStandardColormap(dpy,root,&scmap,XA_RGB_DEFAULT_MAP)) if (!XtcwpCreateRGBDefaultMap(dpy,&scmap)) return None; /* determine window's current colormap */ XGetWindowAttributes(dpy,win,&wa); wcmap = wa.colormap; /* create new colormap and allocate all cells read/write */ cmap = XCreateColormap(dpy,win,DefaultVisualOfScreen(scr),AllocNone); ncells = CellsOfScreen(scr); XAllocColorCells(dpy,cmap,True,NULL,0,pixel,(unsigned int)ncells); /* copy color cells from window's colormap to new colormap */ for (i=0; i<ncells; ++i) { if (i<bpixel || i>epixel) { color.pixel = i; XQueryColor(dpy,wcmap,&color); XFreeColors(dpy,cmap,&i,1,0); XAllocColor(dpy,cmap,&color); } } /* copy RGB color scale from XA_RGB_DEFAULT_MAP to new colormap */ npixels = epixel-bpixel+1; for (i=0; i<npixels; ++i) { color.pixel = bpixel+i; XQueryColor(dpy,scmap.colormap,&color); XStoreColor(dpy,cmap,&color); } /* return colormap */ return cmap; }
int initsystem(void) /* retourne 1 si initialisation reussie */ { int i; int windowW; int windowH; XSetWindowAttributes xswa; XGCValues xgcv; XSizeHints xsh; windowW=WIDTH*RATIO; windowH=HEIGHT*RATIO; display=XOpenDisplay(0); if (!display) return(0); else { mousek=0; XAutoRepeatOff(display); timestart=last=systime(); screen=XDefaultScreenOfDisplay(display); rdepth=sdepth=XDefaultDepthOfScreen(screen); if (emulmono) sdepth=1; XSynchronize(display,0); black=XBlackPixelOfScreen(screen); white=XWhitePixelOfScreen(screen); colormap=XDefaultColormapOfScreen(screen); visual=XDefaultVisualOfScreen(screen); xswa.event_mask=VisibilityChangeMask; xswa.background_pixel=black; xswa.border_pixel=white; xswa.override_redirect=0; xswa.backing_store=Always; xswa.bit_gravity=StaticGravity; xswa.win_gravity=CenterGravity; window=XCreateWindow(display,XRootWindowOfScreen(screen), randval(50),randval(100),windowW,windowH,0, XDefaultDepthOfScreen(screen),InputOutput, XDefaultVisualOfScreen(screen), CWWinGravity|CWBitGravity|CWBackingStore|CWEventMask| CWBackPixel|CWOverrideRedirect|CWBorderPixel,&xswa); if (sdepth!=1) xcolormap=XCreateColormap(display,window, visual,AllocAll); xgcv.foreground = white; xgcv.background = black; gc=XCreateGC(display,window,GCForeground | GCBackground,&xgcv); XSetGraphicsExposures(display,gc,False); /* CAPITAL!!! : evite d'accumuler sans cesse des expose events */ xsh.x=0; xsh.y=0; xsh.width=windowW; xsh.height=windowH; xsh.min_width=windowW; xsh.max_width=windowW; xsh.min_height=windowH; xsh.max_height=windowH; xsh.flags=PPosition|PSize|PMinSize|PMaxSize; XSetNormalHints(display, window, &xsh); XStoreName(display,window,""); XMapWindow(display, window); XSelectInput(display,window,PointerMotionMask|ButtonPressMask| ButtonReleaseMask|KeyPressMask|KeyReleaseMask); XFlush(display); XSync(display,0); for (i=0; i<(NBCOLORS+2); i++) { if (i&1) pixels[i]=white; else pixels[i]=black; if (i==NBCOLORS) pixels[i]=0; if (i==(NBCOLORS+1)) pixels[i]=(1<<rdepth)-1; xgcv.foreground=pixels[i]; xgcv.background=black; gctab[i]=XCreateGC(display,window, GCForeground|GCBackground,&xgcv); XSetFunction(display,gctab[i],GXcopy); XSetFillStyle(display,gctab[i],FillSolid); } ecran[0]=XCreatePixmap(display,window,windowW,windowH,rdepth); ecran[1]=XCreatePixmap(display,window,windowW,windowH,rdepth); for(i=0; i<9; i++) graypixmap[i]=XCreatePixmapFromBitmapData(display,window, &graypat[i][0],8,8,white,black,rdepth); setpalette(egapal); cls(); swap(); cls(); empty(); waitdelay(500); return(1); } }
static int _gfx_x11_init_monitors( int major, int minor) { /* Iterate over all screens */ Screen* def = XDefaultScreenOfDisplay(_gfx_x11.display); unsigned int count = XScreenCount(_gfx_x11.display); while(count--) { /* Get screen resources */ Screen* scr = XScreenOfDisplay(_gfx_x11.display, count); Window root = XRootWindowOfScreen(scr); XRRScreenResources* res = XRRGetScreenResources(_gfx_x11.display, root); RROutput prim = res->outputs[0]; /* Get primary if RandR 1.3 is supported */ if(major > 1 || (major == 1 && minor > 2)) prim = XRRGetOutputPrimary(_gfx_x11.display, root); /* Insert the screen's display modes */ size_t first = _gfx_x11_init_modes(scr, res); /* Iterate through outputs */ unsigned int i; for(i = 0; i < res->noutput; ++i) { /* Validate output */ XRROutputInfo* out = XRRGetOutputInfo(_gfx_x11.display, res, res->outputs[i]); if(out->connection != RR_Connected) { XRRFreeOutputInfo(out); continue; } /* Create new monitor */ XRRCrtcInfo* crtc = XRRGetCrtcInfo(_gfx_x11.display, res, out->crtc); int rot = crtc->rotation & (RR_Rotate_90 | RR_Rotate_270); GFX_X11_Monitor mon = { .screen = scr, .crtc = out->crtc, .mode = crtc->mode, .numModes = 0, .modes = malloc(sizeof(size_t) * out->nmode), .x = crtc->x, .y = crtc->y, .width = rot ? crtc->height : crtc->width, .height = rot ? crtc->width : crtc->height }; /* Retrieve output modes */ unsigned int j; if(mon.modes) for(j = 0; j < out->nmode; ++j) { GFX_X11_Mode* mode; for( mode = gfx_vector_at(&_gfx_x11.modes, first); mode != _gfx_x11.modes.end; mode = gfx_vector_next(&_gfx_x11.modes, mode)) { /* Also check if resolution isn't too big */ if( mode->id == out->modes[j] && mode->mode.width <= crtc->width && mode->mode.height <= crtc->height) { mon.modes[mon.numModes++] = gfx_vector_get_index( &_gfx_x11.modes, mode ); break; } } } /* Insert at beginning if primary */ GFXVectorIterator monPos = scr == def && res->outputs[i] == prim ? _gfx_x11.monitors.begin : _gfx_x11.monitors.end; monPos = gfx_vector_insert(&_gfx_x11.monitors, &mon, monPos); if(monPos == _gfx_x11.monitors.end) free(mon.modes); XRRFreeCrtcInfo(crtc); XRRFreeOutputInfo(out); } XRRFreeScreenResources(res); } /* Need at least one monitor */ return _gfx_x11.monitors.begin != _gfx_x11.monitors.end; } /******************************************************/ static GFXKey _gfx_x11_get_key( KeySym symbol) { /* Unicode numbers */ if(symbol >= XK_0 && symbol <= XK_9) return (GFXKey)(symbol - XK_0 + GFX_KEY_0); /* Keypad numbers */ if(symbol >= XK_KP_0 && symbol <= XK_KP_9) return (GFXKey)(symbol - XK_KP_0 + GFX_KEY_KP_0); /* Unicode capitals */ if(symbol >= XK_A && symbol <= XK_Z) return (GFXKey)(symbol - XK_A + GFX_KEY_A); /* Unicode lowercase */ if(symbol >= XK_a && symbol <= XK_z) return (GFXKey)(symbol - XK_a + GFX_KEY_A); /* Function keys */ if(symbol >= XK_F1 && symbol <= XK_F24) return (GFXKey)(symbol - XK_F1 + GFX_KEY_F1); /* Non-unicode */ switch(symbol) { case XK_VoidSymbol : return GFX_KEY_UNKNOWN; case XK_BackSpace : return GFX_KEY_BACKSPACE; case XK_Tab : return GFX_KEY_TAB; case XK_KP_Tab : return GFX_KEY_TAB; case XK_Clear : return GFX_KEY_CLEAR; case XK_Return : return GFX_KEY_RETURN; case XK_Pause : return GFX_KEY_PAUSE; case XK_Scroll_Lock : return GFX_KEY_SCROLL_LOCK; case XK_Escape : return GFX_KEY_ESCAPE; case XK_Delete : return GFX_KEY_DELETE; case XK_KP_Delete : return GFX_KEY_DELETE; case XK_Home : return GFX_KEY_HOME; case XK_KP_Home : return GFX_KEY_HOME; case XK_Left : return GFX_KEY_LEFT; case XK_KP_Left : return GFX_KEY_LEFT; case XK_Up : return GFX_KEY_UP; case XK_KP_Up : return GFX_KEY_UP; case XK_Right : return GFX_KEY_RIGHT; case XK_KP_Right : return GFX_KEY_RIGHT; case XK_Down : return GFX_KEY_DOWN; case XK_KP_Down : return GFX_KEY_DOWN; case XK_Page_Down : return GFX_KEY_PAGE_DOWN; case XK_KP_Page_Down : return GFX_KEY_PAGE_DOWN; case XK_Page_Up : return GFX_KEY_PAGE_UP; case XK_KP_Page_Up : return GFX_KEY_PAGE_UP; case XK_End : return GFX_KEY_END; case XK_KP_End : return GFX_KEY_END; case XK_Select : return GFX_KEY_SELECT; case XK_Print : return GFX_KEY_PRINT; case XK_Execute : return GFX_KEY_EXECUTE; case XK_Insert : return GFX_KEY_INSERT; case XK_KP_Insert : return GFX_KEY_INSERT; case XK_Menu : return GFX_KEY_MENU; case XK_Cancel : return GFX_KEY_CANCEL; case XK_Help : return GFX_KEY_HELP; case XK_Num_Lock : return GFX_KEY_NUM_LOCK; case XK_KP_Space : return GFX_KEY_SPACE; case XK_space : return GFX_KEY_SPACE; case XK_KP_Enter : return GFX_KEY_KP_RETURN; case XK_KP_Multiply : return GFX_KEY_KP_MULTIPLY; case XK_KP_Add : return GFX_KEY_KP_ADD; case XK_KP_Separator : return GFX_KEY_KP_SEPARATOR; case XK_KP_Subtract : return GFX_KEY_KP_SUBTRACT; case XK_KP_Decimal : return GFX_KEY_KP_DECIMAL; case XK_KP_Divide : return GFX_KEY_KP_DIVIDE; case XK_Shift_L : return GFX_KEY_SHIFT_LEFT; case XK_Shift_R : return GFX_KEY_SHIFT_RIGHT; case XK_Control_L : return GFX_KEY_CONTROL_LEFT; case XK_Control_R : return GFX_KEY_CONTROL_RIGHT; case XK_Alt_L : return GFX_KEY_ALT_LEFT; case XK_Alt_R : return GFX_KEY_ALT_RIGHT; case XK_Super_L : return GFX_KEY_SUPER_LEFT; case XK_Super_R : return GFX_KEY_SUPER_RIGHT; } return GFX_KEY_UNKNOWN; } /******************************************************/ static void _gfx_x11_create_key_table(void) { /* Get permitted keycodes and their symbols */ int minKey, maxKey; XDisplayKeycodes(_gfx_x11.display, &minKey, &maxKey); maxKey = maxKey > GFX_X11_MAX_KEYCODE ? GFX_X11_MAX_KEYCODE : maxKey; int numKeys = maxKey - minKey + 1; int symbolsPerKey; KeySym* symbols = XGetKeyboardMapping( _gfx_x11.display, minKey, numKeys, &symbolsPerKey ); /* Use the first symbol of all keycodes */ size_t i; for(i = minKey; i <= maxKey; ++i) _gfx_x11.keys[i] = _gfx_x11_get_key( symbols[(i - minKey) * symbolsPerKey]); XFree(symbols); }
/** * @brief Return root window for a given X display * @param Screen number. If no value is passed, uses screen 1. * @return XID of the window */ unsigned long X11Extras::appRootWindow(int screen) { return screen == -1 ? XDefaultRootWindow(display()) : XRootWindowOfScreen(XScreenOfDisplay(display(), screen)); }
/*--------------------------------------------------------*/ void open_gwindow_( ) { /* * create new graphics window on first entry.... */ int font,black,white; int scr_width,scr_height; int j; unsigned long valuemask; static int depth; /* number of planes */ static Visual *visual; /*VISUAL TYPE */ static XSizeHints win_position; /*position and size for window manager.*/ /* * initialize display id and screen id.... */ disp_id = XOpenDisplay(0); if (!disp_id) { printf("Display not opened!\n"); exit(-1); } /* * next instruction for debugging only.... */ /* XSynchronize(disp_id, 1); */ screen_id = XDefaultScreenOfDisplay(disp_id); root_win_id = XRootWindowOfScreen(screen_id); black = XBlackPixelOfScreen(screen_id); white = XWhitePixelOfScreen(screen_id); scr_width = XWidthOfScreen(screen_id); scr_height = XHeightOfScreen(screen_id); depth = XDefaultDepthOfScreen(screen_id); visual = XDefaultVisualOfScreen(screen_id); /* * set up backing store.... */ valuemask = CWBitGravity | CWBackingStore | CWBackPixel; setwinattr.bit_gravity = SouthWestGravity; setwinattr.backing_store = Always; setwinattr.background_pixel = white; /* * create the window.... */ win_id = XCreateWindow(disp_id, root_win_id, scr_width - win_width - 15, scr_height - win_height - 35, win_width, win_height, 10, depth, InputOutput, visual, valuemask, &setwinattr); /* WMHints structure */ win_position.x = scr_width - win_width - 15; win_position.y = scr_height - win_height - 35; win_position.width = win_width; win_position.height = win_height; win_position.flags=USPosition|USSize; XSetWMNormalHints(disp_id, win_id, &win_position); XStoreName(disp_id, win_id, WINDNAME); /* * get named color values.... */ color[1] = define_color_("BLUE"); color[2] = define_color_("DEEP SKY BLUE"); color[3] = define_color_("LIGHT SKY BLUE"); color[4] = define_color_("SEA GREEN"); color[5] = define_color_("MEDIUM SEA GREEN"); color[6] = define_color_("GREEN"); color[7] = define_color_("BROWN"); color[8] = define_color_("CHOCOLATE"); color[9] = define_color_("SANDY BROWN"); color[10] = define_color_("RED"); color[11] = define_color_("CORAL"); color[12] = define_color_("ORANGE"); color[13] = define_color_("YELLOW3"); color[14] = define_color_("YELLOW2"); color[15] = define_color_("YELLOW"); color[16] = define_color_("PEACH PUFF"); color[17] = define_color_("PAPAYA WHIP"); color[18] = define_color_("OLD LACE"); color[19] = white; color[20] = black; color[21] = black; /* * create graphics context.... */ xgcvl.background = color[19]; xgcvl.foreground = color[20]; gc_id = XCreateGC(disp_id, win_id, GCForeground | GCBackground, &xgcvl); xgcvl.function = GXinvert; gc_comp_id = XCreateGC(disp_id, win_id, GCFunction, &xgcvl); /* * load the font for text writing.... */ font = XLoadFont(disp_id, FONTNAME); XSetFont(disp_id, gc_id, font); /* Map the window.... */ XSelectInput(disp_id,win_id,ExposureMask|VisibilityChangeMask); XMapRaised(disp_id,win_id); /* * Wait for the window to be raised. Some X servers do not * generate an initial expose event, so also check the visibility * event. */ XMaskEvent(disp_id,ExposureMask|VisibilityChangeMask,&event); XSelectInput(disp_id,win_id,0); XSync(disp_id,1); }
gboolean gf_display_get_workarea(GdkScreen* g_screen, GdkRectangle *rect) { Atom xa_desktops, xa_current, xa_workarea, xa_type; Display *x_display; Window x_root; guint32 desktops = 0, current = 0; gulong *workareas, len, fill; guchar *data; gint format; GdkDisplay *g_display; Screen *x_screen; /* get the gdk display */ g_display = gdk_display_get_default(); if(!g_display) return FALSE; /* get the x display from the gdk display */ x_display = gdk_x11_display_get_xdisplay(g_display); if(!x_display) return FALSE; /* get the x screen from the gdk screen */ x_screen = gdk_x11_screen_get_xscreen(g_screen); if(!x_screen) return FALSE; /* get the root window from the screen */ x_root = XRootWindowOfScreen(x_screen); /* find the _NET_NUMBER_OF_DESKTOPS atom */ xa_desktops = XInternAtom(x_display, "_NET_NUMBER_OF_DESKTOPS", True); if(xa_desktops == None) return FALSE; /* get the number of desktops */ if(XGetWindowProperty(x_display, x_root, xa_desktops, 0, 1, False, XA_CARDINAL, &xa_type, &format, &len, &fill, &data) != Success) { return FALSE; } if(!data) return FALSE; desktops = *(guint32 *)data; XFree(data); /* find the _NET_CURRENT_DESKTOP atom */ xa_current = XInternAtom(x_display, "_NET_CURRENT_DESKTOP", True); if(xa_current == None) return FALSE; /* get the current desktop */ if(XGetWindowProperty(x_display, x_root, xa_current, 0, 1, False, XA_CARDINAL, &xa_type, &format, &len, &fill, &data) != Success) { return FALSE; } if(!data) return FALSE; current = *(guint32 *)data; XFree(data); /* find the _NET_WORKAREA atom */ xa_workarea = XInternAtom(x_display, "_NET_WORKAREA", True); if(xa_workarea == None) return FALSE; if(XGetWindowProperty(x_display, x_root, xa_workarea, 0, (glong)(4 * 32), False, AnyPropertyType, &xa_type, &format, &len, &fill, &data) != Success) { return FALSE; } /* make sure the type and format are good */ if(xa_type == None || format == 0) return FALSE; /* make sure we don't have any leftovers */ if(fill) return FALSE; /* make sure len divides evenly by 4 */ if(len % 4) return FALSE; /* it's good, lets use it */ workareas = (gulong *)(guint32 *)data; rect->x = (guint32)workareas[current * 4]; rect->y = (guint32)workareas[current * 4 + 1]; rect->width = (guint32)workareas[current * 4 + 2]; rect->height = (guint32)workareas[current * 4 + 3]; /* clean up our memory */ XFree(data); return TRUE; }
/* * Class: com_jogamp_nativewindow_impl_x11_X11Lib * Method: CreateDummyWindow * Signature: (JIJ)J */ JNIEXPORT jlong JNICALL Java_com_jogamp_nativewindow_impl_x11_X11Lib_CreateDummyWindow (JNIEnv *env, jclass unused, jlong display, jint screen_index, jlong visualID) { Display * dpy = (Display *)(intptr_t)display; int scrn_idx = (int)screen_index; Window windowParent = 0; Window window = 0; XVisualInfo visualTemplate; XVisualInfo *pVisualQuery = NULL; Visual *visual = NULL; int depth; XSetWindowAttributes xswa; unsigned long attrMask; int n; Screen* scrn; if(NULL==dpy) { _FatalError(env, "invalid display connection.."); return 0; } if(visualID<0) { _throwNewRuntimeException(NULL, env, "invalid VisualID .."); return 0; } x11ErrorHandlerEnable(dpy, 1, env); scrn = ScreenOfDisplay(dpy, scrn_idx); // try given VisualID on screen memset(&visualTemplate, 0, sizeof(XVisualInfo)); visualTemplate.screen = scrn_idx; visualTemplate.visualid = (VisualID)visualID; pVisualQuery = XGetVisualInfo(dpy, VisualIDMask|VisualScreenMask, &visualTemplate,&n); if(pVisualQuery!=NULL) { visual = pVisualQuery->visual; depth = pVisualQuery->depth; visualID = (jlong)pVisualQuery->visualid; XFree(pVisualQuery); pVisualQuery=NULL; } DBG_PRINT( "X11: [CreateWindow] trying given (dpy %p, screen %d, visualID: %d, parent %p) found: %p\n", dpy, scrn_idx, (int)visualID, windowParent, visual); if (visual==NULL) { x11ErrorHandlerEnable(dpy, 0, env); _throwNewRuntimeException(dpy, env, "could not query Visual by given VisualID, bail out!"); return 0; } if(pVisualQuery!=NULL) { XFree(pVisualQuery); pVisualQuery=NULL; } if(0==windowParent) { windowParent = XRootWindowOfScreen(scrn); } attrMask = ( CWBackingStore | CWBackingPlanes | CWBackingPixel | CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect ) ; memset(&xswa, 0, sizeof(xswa)); xswa.override_redirect = False; // use the window manager, always xswa.border_pixel = 0; xswa.background_pixel = 0; xswa.backing_store=NotUseful; /* NotUseful, WhenMapped, Always */ xswa.backing_planes=0; /* planes to be preserved if possible */ xswa.backing_pixel=0; /* value to use in restoring planes */ xswa.event_mask = 0 ; /* no events */ xswa.colormap = XCreateColormap(dpy, XRootWindow(dpy, scrn_idx), visual, AllocNone); window = XCreateWindow(dpy, windowParent, 0, 0, 64, 64, 0, // border width depth, InputOutput, visual, attrMask, &xswa); XSync(dpy, False); XSelectInput(dpy, window, 0); // no events XSync(dpy, False); x11ErrorHandlerEnable(dpy, 0, env); DBG_PRINT( "X11: [CreateWindow] created window %p on display %p\n", window, dpy); return (jlong) window; }
GFX_PlatformWindow _gfx_platform_window_create( const GFX_PlatformAttributes* attributes) { /* Setup the x11 window */ GFX_X11_Window window; window.monitor = attributes->monitor; window.context = NULL; window.flags = 0; window.flags |= attributes->flags & GFX_WINDOW_RESIZABLE ? GFX_X11_RESIZABLE : 0; window.flags |= attributes->flags & GFX_WINDOW_HIDDEN ? GFX_X11_HIDDEN : 0; /* Get display mode & position */ GFXDisplayMode mode; int x = window.monitor->x; int y = window.monitor->y; if(attributes->flags & GFX_WINDOW_FULLSCREEN) { window.flags |= GFX_X11_FULLSCREEN; GFX_X11_Mode* it = gfx_vector_at( &_gfx_x11.modes, window.monitor->modes[attributes->mode] ); window.mode = it->id; mode = it->mode; } else { mode.width = attributes->w; mode.height = attributes->h; mode.depth = *attributes->depth; x += attributes->x; y += attributes->y; } /* Get FB Config */ GLXFBConfig* config = _gfx_x11_get_config( window.monitor->screen, &mode.depth, attributes->flags & GFX_WINDOW_DOUBLE_BUFFER ); if(!config) return NULL; /* Get visual from config */ XVisualInfo* visual = glXGetVisualFromFBConfig( _gfx_x11.display, *config ); window.config = *config; XFree(config); /* Create the window attributes */ unsigned long mask = CWColormap | CWEventMask; XSetWindowAttributes attr; if( attributes->flags & GFX_WINDOW_BORDERLESS || attributes->flags & GFX_WINDOW_FULLSCREEN) { /* Borderless window */ mask |= CWBorderPixel; attr.border_pixel = 0; } /* Event mask & Color map */ Window root = XRootWindowOfScreen(window.monitor->screen); attr.event_mask = KeyPressMask | KeyReleaseMask | PointerMotionMask | EnterWindowMask | LeaveWindowMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask | FocusChangeMask; attr.colormap = XCreateColormap( _gfx_x11.display, root, visual->visual, AllocNone ); /* Create the actual window */ window.handle = XCreateWindow( _gfx_x11.display, root, x, y, mode.width, mode.height, 0, visual->depth, InputOutput, visual->visual, mask, &attr ); XFree(visual); if(window.handle) { /* Get properties to check for events */ XWindowAttributes get; get.x = 0; get.y = 0; get.width = 0; get.height = 0; XGetWindowAttributes(_gfx_x11.display, window.handle, &get); window.x = get.x; window.y = get.y; window.width = get.width; window.height = get.height; /* Delete protocol & name */ XSetWMProtocols( _gfx_x11.display, window.handle, &_gfx_x11.WM_DELETE_WINDOW, 1); XStoreName( _gfx_x11.display, window.handle, attributes->name); /* Disable decorations */ if(mask & CWBorderPixel) { unsigned long hints[5]; hints[0] = MWM_HINTS_DECORATIONS; hints[2] = 0; XChangeProperty( _gfx_x11.display, window.handle, _gfx_x11.MOTIF_WM_HINTS, _gfx_x11.MOTIF_WM_HINTS, 32, PropModeReplace, (unsigned char*)hints, 5); } /* Bypass compositor */ if(attributes->flags & GFX_WINDOW_FULLSCREEN) { unsigned long bypass = 1; XChangeProperty( _gfx_x11.display, window.handle, _gfx_x11.NET_WM_BYPASS_COMPOSITOR, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&bypass, 1 ); } /* Set size hints */ if(!(attributes->flags & GFX_WINDOW_RESIZABLE)) { XSizeHints* hints = XAllocSizeHints(); hints->flags = PMinSize | PMaxSize; hints->min_width = mode.width; hints->max_width = mode.width; hints->min_height = mode.height; hints->max_height = mode.height; XSetWMNormalHints(_gfx_x11.display, window.handle, hints); XFree(hints); } /* Add window to vector */ GFXVectorIterator it = gfx_vector_insert( &_gfx_x11.windows, &window, _gfx_x11.windows.end ); if(it != _gfx_x11.windows.end) { /* Make it visible */ /* Triggers FocusIn event for fullscreen */ if(!(attributes->flags & GFX_WINDOW_HIDDEN)) XMapWindow(_gfx_x11.display, window.handle); return GFX_UINT_TO_VOID(window.handle); } XDestroyWindow(_gfx_x11.display, window.handle); } XFreeColormap(_gfx_x11.display, attr.colormap); return NULL; }
int main (int argc, char **argv) { int n1,n2,nz,iz,verbose,looping,nTic1,nTic2,width,height,interp; float d1,f1,d2,f2,*z, clip,bclip,wclip,white,wfrac, perc,bperc,wperc,*temp, bhue,whue,sat,bright, x1beg,x2beg,x1end,x2end, x1min,x1max,x2min,x2max, fframe,dframe; char *label1="",*label2="",*format="",*windowtitle="", *labelFont="",*titleFont="", *axesColor="",*gridColor="",*titleColor="", *style="normal",*grid1="none",*grid2="none", *cmap; ClientData cd; XrmValue from,to; Widget toplevel,axes; XtAppContext ac; Display *dpy; Window win; Arg args[98]; int nargs; int scr; unsigned int depth; /* initialize getpar */ initargs(argc,argv); requestdoc(1); /* get parameters describing colormaps */ cmap = "gray"; getparstring("cmap",&cmap); if (STREQ("saturation",cmap)) cmap = "sat"; bhue = 0; getparfloat("bhue",&bhue); bhue /= 360.0; whue = 240; getparfloat("whue",&whue); whue /= 360.0; sat = 1.0; getparfloat("sat",&sat); if (sat<0.0 || sat>1.0) err("sat must be in range [0,1]!\n"); bright = 1.0; getparfloat("bright",&bright); if (bright<0.0 || bright>1.0) err("bright must be in range [0,1]!\n"); /* get parameters describing 1st dimension sampling */ if (!getparint("n1",&n1)) err("Must specify number of samples in 1st dimension!\n"); if (!getparfloat("d1",&d1)) d1 = 1.0; if (!getparfloat("f1",&f1)) f1 = 0.0; x1min = (d1>0.0)?f1:f1+(n1-1)*d1; x1max = (d1<0.0)?f1:f1+(n1-1)*d1; if (!getparfloat("x1beg",&x1beg)) x1beg = x1min; if (!getparfloat("x1end",&x1end)) x1end = x1max; /* get parameters describing 2nd dimension sampling */ if (!getparint("n2",&n2)) err("Must specify number of samples in 2nd dimension!\n"); if (!getparfloat("d2",&d2)) d2 = 1.0; if (!getparfloat("f2",&f2)) f2 = 0.0; x2min = (d2>0.0)?f2:f2+(n2-1)*d2; x2max = (d2<0.0)?f2:f2+(n2-1)*d2; if (!getparfloat("x2beg",&x2beg)) x2beg = x2min; if (!getparfloat("x2end",&x2end)) x2end = x2max; /* read first frame of float data */ nz = n1*n2; z = ealloc1float(nz); if (fread(z,sizeof(float),nz,stdin)!=nz) err("error reading input file"); /* if necessary, determine clips from percentiles */ if (getparfloat("clip",&clip)) { bclip = clip; wclip = -clip; } if ((!getparfloat("bclip",&bclip) || !getparfloat("wclip",&wclip)) && !getparfloat("clip",&clip)) { perc = 100.0; getparfloat("perc",&perc); temp = ealloc1float(nz); for (iz=0; iz<nz; iz++) temp[iz] = z[iz]; if (!getparfloat("bclip",&bclip)) { bperc = perc; getparfloat("bperc",&bperc); iz = (nz*bperc/100.0); if (iz<0) iz = 0; if (iz>nz-1) iz = nz-1; qkfind(iz,nz,temp); bclip = temp[iz]; } if (!getparfloat("wclip",&wclip)) { wperc = 100.0-perc; getparfloat("wperc",&wperc); iz = (nz*wperc/100.0); if (iz<0) iz = 0; if (iz>nz-1) iz = nz-1; qkfind(iz,nz,temp); wclip = temp[iz]; } free1float(temp); } if (!getparfloat("white",&white)) white = (bclip+wclip)/2.0; if (!getparint("verbose",&verbose)) verbose = 1; if (!getparint("sleep",&cd.sleep)) cd.sleep=0 ; if (!getparint("loop",&looping)) looping = 0; if (verbose) { if(STREQ(cmap,"sat") || STREQ(cmap,"customsat")) { warn("bclip=%g wclip=%g white=%g",bclip,wclip,white); } else { warn("bclip=%g wclip=%g",bclip,wclip); } } wfrac = (bclip!=wclip) ? (bclip-white)/(bclip-wclip) : 1.0; /* initialize toolkit and set toplevel parameters */ toplevel = XtAppInitialize(&ac,"XMovie_XAPP_DEF",NULL,0,&argc,argv,NULL,NULL,0); dpy = XtDisplay(toplevel); nargs = 0; if (getparstring("windowtitle",&windowtitle)) {XtSetArg(args[nargs],XtNtitle,windowtitle); nargs++;} if (getparstring("windowtitle",&windowtitle)) {XtSetArg(args[nargs],XtNiconName,windowtitle); nargs++;} if (getparint("width",&width)) {XtSetArg(args[nargs],XtNwidth,width); nargs++;} if (getparint("height",&height)) {XtSetArg(args[nargs],XtNheight,height); nargs++;} XtSetArg(args[nargs],XtNinput,TRUE);nargs++; XtSetValues(toplevel,args,nargs); /* if necessary, make private colormap */ win = XRootWindowOfScreen(XtScreen(toplevel)); nargs = 0; scr=DefaultScreen(dpy); depth=(unsigned int)DefaultDepth(dpy,scr); if (depth<=8) { if (STREQ(cmap,"gray")) { Colormap cm=XtcwpCreateGrayColormap(dpy,win); XtSetArg(args[nargs],XtNcolormap,cm); nargs++; } else if (STREQ(cmap,"hue")) { Colormap cm=XtcwpCreateHueColormap(dpy,win, bhue,whue,sat,bright); XtSetArg(args[nargs],XtNcolormap,cm); nargs++; } else if (STREQ(cmap,"sat")) { Colormap cm=XtcwpCreateSatColormap(dpy,win, bhue,whue,wfrac,bright); XtSetArg(args[nargs],XtNcolormap,cm); nargs++; } XtSetValues(toplevel,args,nargs); } /* create axes and set axes parameters */ axes = XtCreateManagedWidget("axes",xtcwpAxesWidgetClass, toplevel,NULL,0); nargs = 0; if (getparstring("grid1",&grid1)) { from.addr = (char *)grid1; XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to); if (to.addr) XtSetArg(args[nargs],XtNgrid1,*((int*)to.addr)); nargs++; } if (getparstring("grid2",&grid2)) { from.addr = (char *)grid2; XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesGrid,&to); if (to.addr) XtSetArg(args[nargs],XtNgrid2,*((int*)to.addr)); nargs++; } if (getparint("nTic1",&nTic1)) {XtSetArg(args[nargs],XtNnTic1,nTic1); nargs++;} if (getparint("nTic2",&nTic2)) {XtSetArg(args[nargs],XtNnTic2,nTic2); nargs++;} if (getparstring("label1",&label1)) {XtSetArg(args[nargs],XtNlabel1,label1); nargs++;} if (getparstring("label2",&label2)) {XtSetArg(args[nargs],XtNlabel2,label2); nargs++;} if (getparstring("title",&format)) {XtSetArg(args[nargs],XtNtitle,format); nargs++;} if (getparstring("style",&style)) { from.size = (unsigned int) strlen(style); from.addr = (char *)style; XtConvertAndStore(axes,XtRString,&from,XtcwpRAxesStyle,&to); if (to.addr) XtSetArg(args[nargs],XtNstyle,*((int*)to.addr)); nargs++; } if (getparstring("axesColor",&axesColor)) { from.addr = (char *)axesColor; XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to); if (to.addr) XtSetArg(args[nargs],XtNaxesColor, *((unsigned long*)to.addr)); nargs++; } if (getparstring("gridColor",&gridColor)) { from.addr = (char *)gridColor; XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to); if (to.addr) XtSetArg(args[nargs],XtNgridColor, *((unsigned long*)to.addr)); nargs++; } if (getparstring("titleColor",&titleColor)) { from.addr = (char *)titleColor; XtConvertAndStore(axes,XtRString,&from,XtRPixel,&to); if (to.addr) XtSetArg(args[nargs],XtNtitleColor, *((unsigned long*)to.addr)); nargs++; } if (getparstring("labelFont",&labelFont)) { from.addr = (char *)labelFont; XtConvertAndStore(axes,XtRString,&from,XtRFont,&to); if (to.addr) XtSetArg(args[nargs],XtNlabelFont, *((Font*)to.addr)); nargs++; } if (getparstring("titleFont",&titleFont)) { from.addr = (char *)titleFont; XtConvertAndStore(axes,XtRString,&from,XtRFont,&to); if (to.addr) XtSetArg(args[nargs],XtNtitleFont, *((Font*)to.addr)); nargs++; } XtSetValues(axes,args,nargs); x1beg = x1min; getparfloat("x1beg",&x1beg); x1end = x1max; getparfloat("x1end",&x1end); x2beg = x2min; getparfloat("x2beg",&x2beg); x2end = x2max; getparfloat("x2end",&x2end); adjustAxesValues(n1,d1,f1,n2,d2,f2,&x1beg,&x1end,&x2beg,&x2end); XtcwpSetAxesValues(axes,x1beg,x1end,x2beg,x2end); /* frame sampling */ if (!getparfloat("fframe",&fframe)) fframe = 1.0; if (!getparfloat("dframe",&dframe)) dframe = 1.0; /* interpolation */ if (!getparint("interp",&interp)) interp = 1; /* initial display mode: cont or step */ if (!getparint("idm", &displayMode)) displayMode = DM_CONT; checkpars(); /* initialize client data */ cd.n1 = n1; cd.d1 = d1; cd.f1 = f1; cd.n2 = n2; cd.d2 = d2; cd.f2 = f2; cd.floats = z; cd.fmin = bclip; cd.fmax = wclip; cd.bmin = (unsigned char) (XtcwpGetFirstPixel(dpy)); cd.bmax = (unsigned char) (XtcwpGetLastPixel(dpy)); if(cd.bmax==0)cd.bmax=255; warn("bmin=%d bmax=%d",cd.bmin,cd.bmax); cd.x1bega = x1beg; cd.x1enda = x1end; cd.x2bega = x2beg; cd.x2enda = x2end; cd.abytes = NULL; cd.bbytes = NULL; cd.image = NULL; cd.exposed = 0; cd.noframes = 1; cd.axes = axes; cd.looping = looping; cd.frame = NULL; cd.format = format; cd.iframe = 0; cd.fframe = fframe; cd.dframe = dframe; cd.interp = interp; cd.forward = 1; cd.ac = ac; /* adjust axes title if formatted */ if (strchr(cd.format,'%') && !strstr(cd.format,"%%")) { sprintf(cd.title,cd.format,cd.fframe+cd.iframe*cd.dframe); XtVaSetValues(cd.axes,XtNtitle,cd.title,NULL); } /* add work procedure */ cd.wpid = XtAppAddWorkProc(ac,(XtWorkProc) readFrame,&cd); /* add callbacks to axes widget */ XtAddCallback(axes,XtNresizeCallback,(XtCallbackProc) resizeCB,&cd); XtAddCallback(axes,XtNexposeCallback,(XtCallbackProc) exposeCB,&cd); XtAddCallback(axes,XtNinputCallback,(XtCallbackProc) inputCB,&cd); /* add Button2 translation for reversing the movie */ XtOverrideTranslations(axes, XtParseTranslationTable("<Btn2Up>: input()")); /* add Button3 translation for pausing the movie */ XtOverrideTranslations(axes, XtParseTranslationTable("<Btn3Up>: input()")); /* set up keypress */ XtAddEventHandler(axes, KeyPress, FALSE, (XtEventHandler) key_pressed, &cd); /* realize everything */ XtRealizeWidget(toplevel); /* go */ XtAppMainLoop(ac); return EXIT_SUCCESS; }
int main(int argc, char **argv) { Widget toplevel, rc, one; XtAppContext app; XtSetLanguageProc(NULL, NULL, NULL); toplevel = XtVaAppInitialize(&app, "BubbleButtonTest", NULL, 0, &argc, argv, NULL, NULL); rc = XmCreateRowColumn(toplevel, "RC", NULL, 0); one = XltCreateBubbleButton(rc, "BubbleButton1", NULL, 0); XtAddCallback(one, XmNactivateCallback, (XtCallbackProc)Callback, NULL); { XmString string; string = XmStringCreateSimple("MouseOver"); XtVaSetValues(one, XmNalignment, XmALIGNMENT_CENTER, XltNmouseOverString, string, NULL); XmStringFree(string); } XtManageChild(one); one = XltCreateBubbleButton(rc, "BubbleButton2", NULL, 0); { Pixmap pixmap; Pixmap pixmap_insens; XpmAttributes attrib; GC gc; { XpmColorSymbol colors[1]; XtVaGetValues(one, XmNbackground, &colors[0].pixel, NULL); colors[0].name = NULL; colors[0].value = "None"; attrib.valuemask = XpmCloseness | XpmColorSymbols; attrib.closeness = 40000; attrib.colorsymbols = colors; attrib.numsymbols = 1; XpmCreatePixmapFromData(XtDisplay(one), XRootWindowOfScreen(XtScreen(one)), dates, &pixmap, NULL, &attrib); pixmap_insens = XCreatePixmap(XtDisplay(one), pixmap, attrib.width, attrib.height, DefaultDepthOfScreen(XtScreen(one))); gc = XDefaultGCOfScreen(XtScreen(one)); XSetFunction(XtDisplay(one),gc,GXcopy); XCopyArea(XtDisplay(one), pixmap, pixmap_insens, gc, 0, 0, attrib.width, attrib.height, 0, 0); XSetFillStyle(XtDisplay(one), gc, FillStippled); XSetStipple(XtDisplay(one), gc, XmGetPixmapByDepth(XtScreen(one), "25_foreground", 1 /*WhitePixelOfScreen(XtScreen(ToolBar))*/, 0 /*BlackPixelOfScreen(XtScreen(ToolBar))*/, 1)); XFillRectangle(XtDisplay(one), pixmap_insens, gc, 0, 0, attrib.width + 1, attrib.height + 1); XpmFreeAttributes(&attrib); XtVaSetValues(one, XmNalignment, XmALIGNMENT_CENTER, XmNlabelType, XmPIXMAP, XmNlabelPixmap, pixmap, XltNmouseOverPixmap, pixmap_insens, NULL); } } XtAddCallback(one, XmNactivateCallback, (XtCallbackProc)Callback, NULL); XtManageChild(one); XtManageChild(rc); XtRealizeWidget(toplevel); XtAppMainLoop(app); exit(0); }
Status XtcwpCreateRGBDefaultMap (Display *dpy, XStandardColormap *scmap) /***************************************************************************** create XA_RGB_DEFAULT_MAP property of root window if it does not already exist ****************************************************************************** Input: dpy display Output: scmap the standard colormap structure ****************************************************************************** Notes: This function returns 0 if the XA_RGB_DEFAULT_MAP property does not exist and cannot be created. At least 8 contiguous color cells must be free in the default colormap to create the XA_RGB_DEFAULT_MAP. If created, the red_max, green_max, and blue_max values returned in scmap will be equal. ****************************************************************************** Author: Dave Hale, Colorado School of Mines, 09/29/90 *****************************************************************************/ { Screen *scr=XDefaultScreenOfDisplay(dpy); Window root=XRootWindowOfScreen(scr); Colormap cmap; XColor color; int i,ncells; unsigned long npixels; unsigned long bpixel,epixel,pixel1,pixel2,imax,rmult,gmult,bmult; unsigned long pixel[4096]; /* grab the server */ XGrabServer(dpy); /* if XA_RGB_DEFAULT_MAP does not exist, then */ if (!XGetStandardColormap(dpy,root,scmap,XA_RGB_DEFAULT_MAP)) { /* use default colormap */ cmap = DefaultColormapOfScreen(scr); /* determine largest number of contiguous free color cells */ ncells = CellsOfScreen(scr); while(ncells && !XAllocColorCells(dpy,cmap,True,NULL,0,pixel,ncells)) ncells--; /* determine beginning and ending pixel of contiguous cells */ for (i=1,bpixel=epixel=pixel1=pixel2=pixel[0]; i<ncells; i++) { if (pixel[i]==pixel[i-1]+1) pixel2 = pixel[i]; else pixel1 = pixel2 = pixel[i]; if (pixel2-pixel1>=epixel-bpixel) { bpixel = pixel1; epixel = pixel2; } } /* number of pixels must be at least 8 */ npixels = epixel-bpixel+1; if (npixels<8) { XUngrabServer(dpy); return 0; } /* force number of contiguous cells to be an integer cubed */ for (i=2,imax=0; i*i*i<=npixels; i++,imax++); npixels = (imax+1)*(imax+1)*(imax+1); bpixel = epixel-npixels+1; /* free cells not in contiguous range */ for (i=0; i<ncells; i++) if (pixel[i]<bpixel || pixel[i]>epixel) XFreeColors(dpy,cmap,&pixel[i],1,0); /* store colors in contiguous range of allocated cells */ rmult = (imax+1)*(imax+1); gmult = imax+1; bmult = 1; for (i=0; i<npixels; i++) { color.pixel = bpixel+i; color.red = (unsigned short) (i/rmult); color.green = (unsigned short) ((i-color.red*rmult)/gmult); color.blue = (unsigned short) (i-color.red*rmult-color.green*gmult); color.red *= 65535/imax; color.green *= 65535/imax; color.blue *= 65535/imax; color.flags = DoRed|DoGreen|DoBlue; XStoreColor(dpy,cmap,&color); } /* set standard colormap */ scmap->colormap = cmap; scmap->red_max = imax; scmap->green_max = imax; scmap->blue_max = imax; scmap->red_mult = rmult; scmap->green_mult = gmult; scmap->blue_mult = bmult; scmap->base_pixel = bpixel; XSetStandardColormap(dpy,root,scmap,XA_RGB_DEFAULT_MAP); } /* ungrab the server before returning */ XUngrabServer(dpy); return 1; }