/*------------------------------------------------ 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;
}
